package gudusoft.gsqlparser.dlineage;

import gudusoft.gsqlparser.dlineage.symbol.LocalScopes;
import gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey;
import gudusoft.gsqlparser.dlineage.routine.RoutineAliasKey;
import gudusoft.gsqlparser.dlineage.routine.RoutineAliasRegistry;
import gudusoft.gsqlparser.dlineage.routine.RoutineAliases;
import gudusoft.gsqlparser.dlineage.comment.CommentBindingCollector;
import gudusoft.gsqlparser.dlineage.comment.CommentBindingBundle;
import gudusoft.gsqlparser.dlineage.comment.CommentBindingProjection;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.common.structured.StructuredAdapterContext;
import gudusoft.gsqlparser.common.structured.StructuredDataflowDescriptor;
import gudusoft.gsqlparser.common.structured.StructuredDataflowRegistry;
import gudusoft.gsqlparser.common.structured.StructuredFieldBinding;
import gudusoft.gsqlparser.common.structured.StructuredValueSource;
import gudusoft.gsqlparser.dlineage.dataflow.listener.DataFlowHandleListener;
import gudusoft.gsqlparser.dlineage.dataflow.metadata.MetadataReader;
import gudusoft.gsqlparser.dlineage.dataflow.metadata.grabit.GrabitMetadataAnalyzer;
import gudusoft.gsqlparser.dlineage.dataflow.metadata.sqldep.SQLDepMetadataAnalyzer;
import gudusoft.gsqlparser.dlineage.dataflow.metadata.sqlflow.SqlflowMetadataAnalyzer;
import gudusoft.gsqlparser.dlineage.dataflow.metadata.sqlflow.sharded.SqlflowShardedMetadataAnalyzer;
import gudusoft.gsqlparser.dlineage.impl.powerquery.PowerQueryLineageResult;
import gudusoft.gsqlparser.dlineage.impl.powerquery.TPowerQueryAnalyzer;
import gudusoft.gsqlparser.dlineage.dataflow.model.*;
import gudusoft.gsqlparser.dlineage.dataflow.model.Process;
import gudusoft.gsqlparser.dlineage.dataflow.model.JoinRelationship.JoinClauseType;
import gudusoft.gsqlparser.dlineage.dataflow.model.json.Coordinate;
import gudusoft.gsqlparser.dlineage.dataflow.model.json.Dataflow;
import gudusoft.gsqlparser.dlineage.dataflow.model.json.Error;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.*;
import gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlTrustMode;
import gudusoft.gsqlparser.dlineage.dataflow.sqlenv.SQLEnvParser;
import gudusoft.gsqlparser.dlineage.metadata.MetadataUtil;
import gudusoft.gsqlparser.dlineage.metadata.Sqlflow;
import gudusoft.gsqlparser.dlineage.util.*;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.nodes.*;
import gudusoft.gsqlparser.nodes.couchbase.TObjectConstruct;
import gudusoft.gsqlparser.nodes.couchbase.TPair;
import gudusoft.gsqlparser.nodes.functions.TJsonObjectFunction;
import gudusoft.gsqlparser.nodes.hive.THiveTransformClause;
import gudusoft.gsqlparser.nodes.hive.THiveTransformClause.ETransformType;
import gudusoft.gsqlparser.resolver2.ScopeBuildResult;
import gudusoft.gsqlparser.resolver2.TSQLResolver2;
import gudusoft.gsqlparser.sqlenv.*;
import gudusoft.gsqlparser.sqlenv.parser.TJSONSQLEnvParser;
import gudusoft.gsqlparser.sqlenv.parser.sqlflow.SqlflowNameForm;
import gudusoft.gsqlparser.stmt.*;
import gudusoft.gsqlparser.stmt.db2.TDb2CallStmt;
import gudusoft.gsqlparser.stmt.db2.TDb2ReturnStmt;
import gudusoft.gsqlparser.stmt.db2.TDb2SqlVariableDeclaration;
import gudusoft.gsqlparser.stmt.hive.THiveLoad;
import gudusoft.gsqlparser.stmt.mssql.*;
import gudusoft.gsqlparser.stmt.mysql.TLoadDataStmt;
import gudusoft.gsqlparser.stmt.oracle.*;
import gudusoft.gsqlparser.stmt.powerquery.TPowerQueryDocumentStmt;
import gudusoft.gsqlparser.stmt.redshift.TRedshiftCopy;
import gudusoft.gsqlparser.stmt.redshift.TRedshiftDeclare;
import gudusoft.gsqlparser.stmt.snowflake.*;
import gudusoft.gsqlparser.stmt.teradata.TTeradataCreateProcedure;
import gudusoft.gsqlparser.util.*;
import gudusoft.gsqlparser.util.json.JSON;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.io.*;
import java.util.zip.GZIPInputStream;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import static gudusoft.gsqlparser.EJoinType.right;

@SuppressWarnings("rawtypes")
/**
 * Single-threaded data flow analyzer that performs lineage analysis on SQL scripts.
 *
 * <h2>Avoiding OOM with Large Files</h2>
 * <p>
 * Analyzing very large SQL files or manifests (e.g. sqlflow-sharded exports with many
 * shards) in a single JVM can easily exhaust heap memory and cause {@code OutOfMemoryError}.
 * To avoid OOM, enable automatic large-file detection and delegation:
 *
 * <pre>{@code
 * Option option = new Option();
 * option.setAutoDetectLargeFile(true);                        // enable auto-detection
 * option.setLargeSqlInfoCountThreshold(1000);                 // max SqlInfo entries before delegating
 * option.setLargeSqlTotalSizeThreshold(25 * 1024 * 1024);     // max total SQL size (25 MB) before delegating
 * option.setLargeQueryCountThreshold(1000);                   // max manifest queries before delegating
 * option.setLargeShardCountThreshold(10);                     // max sharded source files before delegating
 * option.setLargeFileSplitSizeMB(5);                          // split files larger than 5 MB
 * option.setEstimatedMemoryPerTaskMB(2560);                   // estimated memory per parallel task (2.5 GB)
 * option.setParallel(0);                                      // 0 = auto-calculate from CPU cores
 *
 * DataFlowAnalyzer analyzer = new DataFlowAnalyzer(sqlFiles, option);
 * analyzer.generateDataFlow();
 * }</pre>
 *
 * <p>
 * When {@code autoDetectLargeFile} is enabled, {@link #generateDataFlow(boolean)} invokes
 * {@link gudusoft.gsqlparser.dlineage.util.LargeFileDetector} to check the input scale against
 * the configured thresholds. If any threshold is exceeded, the analyzer automatically delegates
 * to {@link gudusoft.gsqlparser.dlineage.ParallelDataFlowAnalyzer}, which:
 * <ul>
 *   <li>Splits large files into smaller chunks via {@link gudusoft.gsqlparser.util.FileSplitter}</li>
 *   <li>Processes each chunk in a separate {@code DataFlowAnalyzer} instance within a bounded
 *       thread pool (size capped by {@code estimatedMemoryPerTaskMB})</li>
 *   <li>For sharded manifests, distributes individual shard source files across parallel tasks</li>
 *   <li>Merges results from all parallel tasks into a single dataflow output</li>
 * </ul>
 *
 * <p>
 * If delegation fails for any reason, the analyzer falls back to single-threaded processing
 * with a warning log, so the analysis still completes (though it may OOM on very large inputs).
 *
 * @see gudusoft.gsqlparser.dlineage.util.LargeFileDetector
 * @see gudusoft.gsqlparser.dlineage.ParallelDataFlowAnalyzer
 * @see gudusoft.gsqlparser.dlineage.dataflow.model.Option#setAutoDetectLargeFile(boolean)
 */
public class DataFlowAnalyzer implements IDataFlowAnalyzer {

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

        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", });

        private static final List<String> CONSTANT_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", "GETDATE" });

        private Stack<TCustomSqlStatement> stmtStack = new Stack<TCustomSqlStatement>();
        private List<ResultSet> appendResultSets = new ArrayList<ResultSet>();
        private Set<TCustomSqlStatement> accessedStatements = new HashSet<TCustomSqlStatement>();
        private Set<TSelectSqlStatement> accessedSubqueries = new HashSet<TSelectSqlStatement>();
        /** A view's or synonym's DDL by the identity of its name as written (DlineageUtil.getTableIdentityKey). */
        private Map<Object, TCustomSqlStatement> viewDDLMap = new HashMap<Object, TCustomSqlStatement>();
        // The script's routine definitions, by the routine's name as written with its argument-count suffix, for calls
        // that precede the definition they call.
        private final RoutineAliasRegistry<TCustomSqlStatement> procedureDDLAliases = new RoutineAliasRegistry<TCustomSqlStatement>();
        private final Map<OraclePackage, List<Pair<TBasicStmt, Procedure>>> pendingOracleCallArguments =
                        new IdentityHashMap<OraclePackage, List<Pair<TBasicStmt, Procedure>>>();
        // EXECs whose callee had no definition yet, in call order; their arguments are bound after the last unit
        // (see bindDeferredExecuteArguments).
        private final Map<TMssqlExecute, DeferredExecuteBinding> deferredExecuteBindings =
                        new LinkedHashMap<TMssqlExecute, DeferredExecuteBinding>();
        // Every statement analyzeCustomSqlStmt is analyzing, outermost first: a statement analyzed inside a dynamic SQL
        // site has that site's statement below it.
        private final List<TCustomSqlStatement> analysisPath = new ArrayList<TCustomSqlStatement>();
        private Map<TTable, TObjectNameList> structObjectMap = new HashMap<TTable, TObjectNameList>();
        private final Set<TParseTreeNode> processingFunctions = new HashSet<TParseTreeNode>();

        // perf (10x, perf/column-lineage-10x): normalized-column-name -> first ResultColumn index over a
        // resultset's column list. analyzeDataFlowRelation otherwise LINEAR-scans queryTable.getColumns()
        // once per target column => O(W^2) for wide resultsets (now the dominant dlineage hotspot after the
        // CTENamespace memo). Keyed by the getColumns() list identity, which is the stable ResultSet.columns
        // field. Only built for "simple" column lists (no star, no struct) because the linear scan has ordered
        // side effects on star/struct columns; other lists fall back to the scan. Rebuilt when size changes.
        // The fast path is used only when it is byte-identical to the scan (verified over the full corpus).
        private final java.util.IdentityHashMap<List<ResultColumn>, ColumnNameIndex> columnNameIndexCache =
                        new java.util.IdentityHashMap<List<ResultColumn>, ColumnNameIndex>();

        /** Cached identifier key -> first ResultColumn map for a simple resultset column list. */
        private static final class ColumnNameIndex {
                final int size;
                /** null when the column list is NOT simple (has a star or struct column) — use the linear scan. */
                final Map<CanonKey, ResultColumn> byIdentifier;
                ColumnNameIndex(int size, Map<CanonKey, ResultColumn> byIdentifier) {
                        this.size = size;
                        this.byIdentifier = byIdentifier;
                }
        }

        /**
         * Return the identity index for {@code columns}, rebuilding when the list size changes.
         * An unidentified expression, star or struct requires the ordered linear scan.
         */
        private ColumnNameIndex getColumnNameIndex(List<ResultColumn> columns) {
                ColumnNameIndex idx = columnNameIndexCache.get(columns);
                if (idx != null && idx.size == columns.size()) {
                        return idx;
                }
                Map<CanonKey, ResultColumn> map = new HashMap<>();
                boolean simple = true;
                for (int i = 0; i < columns.size(); i++) {
                        ResultColumn c = columns.get(i);
                        if (c.getIdentifierKey() == null || c.isStruct()) {
                                simple = false;
                                break;
                        }
                        // putIfAbsent semantics: keep the FIRST column for a given identity, matching the
                        // linear scan's first-match-wins + break.
                        CanonKey key = c.getIdentifierKey();
                        if (!map.containsKey(key)) {
                                map.put(key, c);
                        }
                }
                idx = new ColumnNameIndex(columns.size(), simple ? map : null);
                columnNameIndexCache.put(columns, idx);
                return idx;
        }

        // perf: normalized-column-name -> ResultColumn map for a resultset's column list, used by
        // appendStarRelation to avoid O(S*C) linear scans per star column. Unlike ColumnNameIndex,
        // this cache does NOT require "simple" column lists — it works for any list including those
        // with star/struct columns, because appendStarRelation only needs O(1) lookup, not the
        // ordered side effects that the linear scan in analyzeDataFlowRelation provides.
        private final java.util.IdentityHashMap<List<ResultColumn>, StarLinkColumnIndex<ResultColumn>> resultSetColumnLookupCache =
                        new java.util.IdentityHashMap<List<ResultColumn>, StarLinkColumnIndex<ResultColumn>>();

        private StarLinkColumnIndex<ResultColumn> getResultSetColumnLookup(List<ResultColumn> columns) {
                StarLinkColumnIndex<ResultColumn> index = resultSetColumnLookupCache.get(columns);
                if (index == null) {
                        index = new StarLinkColumnIndex<ResultColumn>(columns);
                        resultSetColumnLookupCache.put(columns, index);
                }
                return index;
        }

        // perf: normalized-column-name -> TableColumn map for a table's column list, used by
        // appendStarRelation to avoid O(C) linear scans via searchTableColumn.
        private final java.util.IdentityHashMap<List<TableColumn>, StarLinkColumnIndex<TableColumn>> tableColumnLookupCache =
                        new java.util.IdentityHashMap<List<TableColumn>, StarLinkColumnIndex<TableColumn>>();

        private StarLinkColumnIndex<TableColumn> getTableColumnLookup(List<TableColumn> columns) {
                StarLinkColumnIndex<TableColumn> index = tableColumnLookupCache.get(columns);
                if (index == null) {
                        index = new StarLinkColumnIndex<TableColumn>(columns);
                        tableColumnLookupCache.put(columns, index);
                }
                return index;
        }

        private SqlInfo[] sqlInfos;
        private File[] originalFiles;
        private List<ErrorInfo> errorInfos = new ArrayList<ErrorInfo>();
        private final List<DynamicSqlSite> dynamicSqlSites = new ArrayList<DynamicSqlSite>();
        // The index in dynamicSqlSites of the last site each statement recorded (see attributeToEnclosingDynamicSite).
        private final Map<TCustomSqlStatement, Integer> dynamicSiteIndexes =
                        new IdentityHashMap<TCustomSqlStatement, Integer>();
        /**
         * The index in dynamicSqlSites of the site each statement of an evaluated variant's text belongs to: one EXEC
         * records a site per variant, and a statement of one variant's text is that variant's (Mantis 4962).
         */
        private final Map<TCustomSqlStatement, Integer> dynamicInnerSiteIndexes =
                        new IdentityHashMap<TCustomSqlStatement, Integer>();
        private final Set<CteSelectRelationKey> cteSelectRelationKeys = new HashSet<CteSelectRelationKey>();
        /**
         * Per-procedure evaluation variants for the default dynamic-SQL path (identity keys).
         * Index 0 is the no-bindings evaluation; further entries are one per literal call-site
         * binding set discovered in the same file (capped).
         */
        private final Map<TCustomSqlStatement, DynamicEvaluation> dynamicEvalCache = new IdentityHashMap<TCustomSqlStatement, DynamicEvaluation>();

        /**
         * One procedure's default-path dynamic-SQL evaluation, built once per procedure node: the materialized
         * variants (no bindings first, then one group per call-site binding set) and the notes every dynamic site of
         * the procedure reports, an evaluation step that failed or a call site that was not bound (Mantis 4962).
         */
        private static final class DynamicEvaluation {
                final List<Map<TCustomSqlStatement, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>> variants =
                                new ArrayList<Map<TCustomSqlStatement, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>>();
                final List<String> notes = new ArrayList<String>();
                /**
                 * The call-site bindings stand for every call of the procedure in the analysis (Mantis 4962): only then is
                 * a site some binding reached published with its bound variants alone.
                 */
                boolean bindingsExhaustive = true;
                /**
                 * The procedure's presets are more than the evaluation takes (maxBindings): no variant of it stands for them,
                 * and none evaluated without them is published in their place.
                 */
                boolean presetsRejected;

                void note(String note) {
                        if (note != null && !notes.contains(note)) {
                                notes.add(note);
                        }
                }
        }
        /**
         * Multi-file mssql analyses only (plan Phase 5): the raw text of every analysis
         * unit, so parameter-dependent dynamic SQL in one file can pick up literal EXEC
         * bindings from another. Null in single-file analyses — the cross-file discovery
         * path is then never entered and per-file output is byte-identical to before.
         */
        private final Map<String, TStatementList> crossFileParseCache = new HashMap<String, TStatementList>();
        /** Shared routine/call-site index over all units (plan §5.6); null in single-file analyses. */
        private gudusoft.gsqlparser.dlineage.dynamicsql.RoutineCatalog routineCatalog;
        /** Oracle files (by unit text) already run through the PL/SQL interpreter this analysis. */
        private final Set<String> plsqlEvaluatedTexts = new HashSet<String>();
        private IndexedLinkedHashMap<String, List<SqlInfo>> sqlInfoMap = new IndexedLinkedHashMap<String, List<SqlInfo>>();
        private TSQLEnv sqlenv = null;
        /**
         * The identifier configuration this analysis runs under, snapshotted once at the
         * {@code generateDataFlow} entry (see {@link #freezeIdentifierProfile()}). Null until then.
         *
         * <p>A snapshot, not a live read of {@link Option}: the option object is mutable and public,
         * and an analysis whose rules could change halfway would have indexed part of its catalog
         * under one relation and probed it under another.
         */
        private IdentifierProfile frozenIdentifierProfile = null;
        private IdentifierService frozenIdentifierService = null;
        /**
         * Package-private, not private, for white-box tests (they read it through the test helper
         * {@code gudusoft.gsqlparser.dlineage.AnalyzerModels}): the shipment obfuscates this name, and the obfuscation
         * gate remaps a direct field reference but never a reflective {@code getDeclaredField("modelManager")}.
         */
        ModelBindingManager modelManager = new ModelBindingManager();
        private ModelFactory modelFactory = new ModelFactory(modelManager);
        private PipelinedFunctionAnalyzer pipelinedAnalyzer;
        private List<Long> tableIds = new ArrayList<Long>();
        private TTableList hiveFromTables;
        private dataflow dataflow;
    private CommentBindingCollector commentBindingCollector;
    private String commentSourceKey;
        private String dataflowString;
        /**
         * Package-private, not private, so a white-box test can seed a draft through the test helper
         * {@code gudusoft.gsqlparser.dlineage.AnalyzerModels}: the shipment obfuscates this name, and the obfuscation
         * gate remaps a direct field reference but never a reflective {@code getDeclaredField} lookup.
         */
        final AuthoritativeLineageEvidenceCollector authoritativeEvidenceCollector =
                        new AuthoritativeLineageEvidenceCollector();

        /**
         * Whether this analyzer is still holding authoritative-evidence DRAFT state.
         *
         * <p>Drafts are per-analysis working state; the lifecycle invariant is that
         * none are retained once a generation completes or the analyzer is disposed.
         * Always false in normal use — a true here means evidence accumulated across
         * analyses, which would leak one analysis's findings into the next.</p>
         *
         * <p>This deliberately exposes the INVARIANT, not the collector: the
         * collector class and its fields stay package-private, so they remain free to
         * change, and nothing internal is frozen into the public API. It is public so
         * the assertion can be made against the shipped (ProGuard-obfuscated) jar,
         * where package-private members are renamed and unreachable.</p>
         *
         * @return true if any evidence draft state is still held
         * @since 4.2.6
         */
        public boolean hasRetainedEvidenceDrafts() {
                return authoritativeEvidenceCollector.hasRetainedDrafts();
        }
        private AuthoritativeLineageEvidence authoritativeLineageEvidence =
                        AuthoritativeLineageEvidence.empty();
        private Option option = new Option();

        {
                modelManager.TABLE_COLUMN_ID = option.getStartId();
                modelManager.RELATION_ID = option.getStartId();
                ModelBindingManager.set(modelManager);
                ModelBindingManager.setGlobalStmtStack(stmtStack);
                ModelBindingManager.setGlobalOption(option);
                ModelBindingManager.setGlobalSqlInfo(sqlInfoMap);
        }

    private void initPipelinedFunctionAnalyzer() {
        // Only initialize pipelinedAnalyzer for Oracle
        if (option.getVendor() == EDbVendor.dbvoracle)
        {
            pipelinedAnalyzer = new PipelinedFunctionAnalyzer(modelManager, modelFactory, option);
        }
        else{
            pipelinedAnalyzer = null;
        }
    }

    public DataFlowAnalyzer(Sqlflow sqlflow, Option option) {
        this.option = option;
        ModelBindingManager.setGlobalOption(this.option);

        SqlInfo info = new SqlInfo();
        info.setOriginIndex(0);

        File tempFile = LargeFileDetector.writeSqlflowToTempFile(sqlflow);

        if (option.isAutoDetectLargeFile() && tempFile.length() > option.getLargeSqlThresholdBytes()) {
            info.setFilePath(tempFile.getAbsolutePath());
            info.setFileName(tempFile.getName());
            this.sqlInfos = new SqlInfo[] { info };
            return;
        }

        String sql = SQLUtil.getFileContent(tempFile);
        tempFile.delete();
        info.setSql(sql);

        this.sqlInfos = convertSQL(option.getVendor(), JSON.toJSONString(new SqlInfo[] { info })).toArray(new SqlInfo[0]);
    }

    public DataFlowAnalyzer(String sqlContent, Option option) {
                SqlInfo[] sqlInfos = new SqlInfo[1];
                SqlInfo info = new SqlInfo();
                info.setSql(sqlContent);
                info.setOriginIndex(0);
                sqlInfos[0] = info;
                this.option = option;
                ModelBindingManager.setGlobalOption(this.option);
                if (option.isLargeSql(sqlContent)) {
                        LargeFileDetector.persistSqlToTempFile(info, sqlContent);
            this.sqlInfos = sqlInfos;
                }
        else {
            this.sqlInfos = convertSQL(option.getVendor(), JSON.toJSONString(sqlInfos)).toArray(new SqlInfo[0]);
        }
    }

    public DataFlowAnalyzer(String sqlContent, EDbVendor dbVendor, boolean simpleOutput, String defaultServer,
                        String defaultDatabase, String defaltSchema) {
                SqlInfo[] sqlInfos = new SqlInfo[1];
                SqlInfo info = new SqlInfo();
                info.setSql(sqlContent);
                info.setOriginIndex(0);
                sqlInfos[0] = info;
                option.setVendor(dbVendor);
                option.setSimpleOutput(simpleOutput);
                option.setDefaultServer(defaultServer);
                option.setDefaultDatabase(defaultDatabase);
                option.setDefaultSchema(defaltSchema);
                this.sqlInfos = convertSQL(dbVendor, JSON.toJSONString(sqlInfos)).toArray(new SqlInfo[0]);
        }

        public DataFlowAnalyzer(String sqlContent, EDbVendor dbVendor, boolean simpleOutput) {
                SqlInfo[] sqlInfos = new SqlInfo[1];
                SqlInfo info = new SqlInfo();
                info.setSql(sqlContent);
                info.setOriginIndex(0);
                sqlInfos[0] = info;
                option.setVendor(dbVendor);
                option.setSimpleOutput(simpleOutput);
                this.sqlInfos = convertSQL(dbVendor, JSON.toJSONString(sqlInfos)).toArray(new SqlInfo[0]);
    }

        public DataFlowAnalyzer(String[] sqlContents, Option option) {
                SqlInfo[] sqlInfos = new SqlInfo[sqlContents.length];
                for (int i = 0; i < sqlContents.length; i++) {
                        SqlInfo info = new SqlInfo();
                        info.setSql(sqlContents[i]);
                        info.setOriginIndex(0);
                        sqlInfos[i] = info;
                }
                this.option = option;
                ModelBindingManager.setGlobalOption(this.option);
                this.sqlInfos = convertSQL(option.getVendor(), JSON.toJSONString(sqlInfos)).toArray(new SqlInfo[0]);
        }

        public DataFlowAnalyzer(String[] sqlContents, EDbVendor dbVendor, boolean simpleOutput, String defaultServer,
                        String defaultDatabase, String defaltSchema) {
                SqlInfo[] sqlInfos = new SqlInfo[sqlContents.length];
                for (int i = 0; i < sqlContents.length; i++) {
                        SqlInfo info = new SqlInfo();
                        info.setSql(sqlContents[i]);
                        info.setOriginIndex(0);
                        sqlInfos[i] = info;
                }
                option.setVendor(dbVendor);
                option.setSimpleOutput(simpleOutput);
                option.setDefaultServer(defaultServer);
                option.setDefaultDatabase(defaultDatabase);
                option.setDefaultSchema(defaltSchema);
                this.sqlInfos = convertSQL(dbVendor, JSON.toJSONString(sqlInfos)).toArray(new SqlInfo[0]);
        }

        public DataFlowAnalyzer(String[] sqlContents, EDbVendor dbVendor, boolean simpleOutput) {
                SqlInfo[] sqlInfos = new SqlInfo[sqlContents.length];
                for (int i = 0; i < sqlContents.length; i++) {
                        SqlInfo info = new SqlInfo();
                        info.setSql(sqlContents[i]);
                        info.setOriginIndex(0);
                        sqlInfos[i] = info;
                }
                option.setVendor(dbVendor);
                option.setSimpleOutput(simpleOutput);
                this.sqlInfos = convertSQL(dbVendor, JSON.toJSONString(sqlInfos)).toArray(new SqlInfo[0]);
        }

        public DataFlowAnalyzer(SqlInfo[] sqlInfos, Option option) {
                this.sqlInfos = sqlInfos;
                this.option = option;
                ModelBindingManager.setGlobalOption(this.option);
        }

        public DataFlowAnalyzer(SqlInfo[] sqlInfos, EDbVendor dbVendor, boolean simpleOutput) {
                this.sqlInfos = sqlInfos;
                option.setVendor(dbVendor);
                option.setSimpleOutput(simpleOutput);
        }

        public DataFlowAnalyzer(File[] sqlFiles, Option option) {
                this.originalFiles = sqlFiles;
                SqlInfo[] sqlInfos = new SqlInfo[sqlFiles.length];
                for (int i = 0; i < sqlFiles.length; i++) {
                        SqlInfo info = new SqlInfo();
                        info.setFileName(sqlFiles[i].getName());
                        info.setFilePath(sqlFiles[i].getAbsolutePath());
                        info.setOriginIndex(0);
                        sqlInfos[i] = info;
                }
                this.sqlInfos = sqlInfos;
                this.option = option;
                ModelBindingManager.setGlobalOption(this.option);
        }

        public DataFlowAnalyzer(File[] sqlFiles, EDbVendor dbVendor, boolean simpleOutput) {
                this.originalFiles = sqlFiles;
                SqlInfo[] sqlInfos = new SqlInfo[sqlFiles.length];
                for (int i = 0; i < sqlFiles.length; i++) {
                        SqlInfo info = new SqlInfo();
                        info.setFileName(sqlFiles[i].getName());
                        info.setFilePath(sqlFiles[i].getAbsolutePath());
                        info.setOriginIndex(0);
                        sqlInfos[i] = info;
                }
                this.sqlInfos = sqlInfos;
                option.setVendor(dbVendor);
                option.setSimpleOutput(simpleOutput);
        }

        public DataFlowAnalyzer(File sqlFile, Option option) {
                File[] children = SQLUtil.listFiles(sqlFile);
                this.originalFiles = children;
                SqlInfo[] sqlInfos = new SqlInfo[children.length];
                for (int i = 0; i < children.length; i++) {
                        SqlInfo info = new SqlInfo();
                        info.setFileName(children[i].getName());
                        info.setFilePath(children[i].getAbsolutePath());
                        info.setOriginIndex(0);
                        sqlInfos[i] = info;
                }
                this.sqlInfos = sqlInfos;
                this.option = option;
                ModelBindingManager.setGlobalOption(this.option);
        }

        public DataFlowAnalyzer(File sqlFile, EDbVendor dbVendor, boolean simpleOutput) {
                File[] children = SQLUtil.listFiles(sqlFile);
                this.originalFiles = children;
                List<SqlInfo> sqlInfos = new ArrayList<>();
                for (int i = 0; i < children.length; i++) {
                        SqlInfo info = new SqlInfo();
                        info.setSql(SQLUtil.getFileContent(children[i]));
            if(children[i].getName().toLowerCase(Locale.ROOT).endsWith(".csv")){
                if(!MetadataReader.isMetadata(info.getSql())){
                    continue;
                }
            }
            else if(children[i].getName().toLowerCase(Locale.ROOT).endsWith(".json")){
                if (!(MetadataReader.isGrabit(info.getSql()) || MetadataReader.isSqlflow(info.getSql()) || MetadataReader.isSqlflowSharded(info.getSql()))){
                    continue;
                }
            }
                        info.setFileName(children[i].getName());
                        info.setFilePath(children[i].getAbsolutePath());
                        info.setOriginIndex(0);
                        sqlInfos.add(info);
                }
                this.sqlInfos = sqlInfos.toArray(new SqlInfo[0]);
                option.setVendor(dbVendor);
                option.setSimpleOutput(simpleOutput);
        }

        public boolean isIgnoreRecordSet() {
                return option.isIgnoreRecordSet();
        }

        public void setIgnoreRecordSet(boolean ignoreRecordSet) {
                option.setIgnoreRecordSet(ignoreRecordSet);
        }

        public boolean isSimpleShowTopSelectResultSet() {
                return option.isSimpleShowTopSelectResultSet();
        }

        public void setSimpleShowTopSelectResultSet(boolean simpleShowTopSelectResultSet) {
                option.setSimpleShowTopSelectResultSet(simpleShowTopSelectResultSet);
        }

        public boolean isSimpleShowFunction() {
                return option.isSimpleShowFunction();
        }

        public void setSimpleShowFunction(boolean simpleShowFunction) {
                option.setSimpleShowFunction(simpleShowFunction);
        }

        /**
         * Whether this analysis leaves its relationship endpoints labelled as their producers spelled them, for the
         * parallel analyzer to merge them first: a merge decides which relationships are one by their labels too, so the
         * endpoints are labelled by their columns only once, after the last merge ({@link DataflowUtility#labelEndpoints}).
         */
        private boolean endpointLabelsDeferred;

        /** Leaves the labelling of endpoints to the parallel analyzer's merge. */
        void deferEndpointLabels() {
                endpointLabelsDeferred = true;
        }

        public boolean isShowJoin() {
                return option.isShowJoin();
        }

        public void setShowJoin(boolean showJoin) {
                option.setShowJoin(showJoin);
        }

        public void setShowCallRelation(boolean showCallRelation) {
                option.setShowCallRelation(showCallRelation);
        }

        public boolean isShowCallRelation() {
                return option.isShowCallRelation();
        }

        public boolean isShowImplicitSchema() {
                return option.isShowImplicitSchema();
        }

        public void setShowImplicitSchema(boolean showImplicitSchema) {
                option.setShowImplicitSchema(showImplicitSchema);
        }

        public boolean isShowConstantTable() {
                return option.isShowConstantTable();
        }

        public void setShowConstantTable(boolean showConstantTable) {
                option.setShowConstantTable(showConstantTable);
        }

        public boolean isShowCountTableColumn() {
                return option.isShowCountTableColumn();
        }

        public void setShowCountTableColumn(boolean showCountTableColumn) {
                option.setShowCountTableColumn(showCountTableColumn);
        }

        public boolean isTransform() {
                return option.isTransform();
        }

        public void setTransform(boolean transform) {
                option.setTransform(transform);
                if (option.isTransformCoordinate()) {
                        option.setTransform(true);
                }
        }

        public boolean isTransformCoordinate() {
                return option.isTransformCoordinate();
        }

        public void setTransformCoordinate(boolean transformCoordinate) {
                option.setTransformCoordinate(transformCoordinate);
                if (transformCoordinate) {
                        option.setTransform(true);
                }
        }

        public boolean isLinkOrphanColumnToFirstTable() {
                return option.isLinkOrphanColumnToFirstTable();
        }

        public void setLinkOrphanColumnToFirstTable(boolean linkOrphanColumnToFirstTable) {
                option.setLinkOrphanColumnToFirstTable(linkOrphanColumnToFirstTable);
        }

        public boolean isIgnoreTemporaryTable() {
                return option.isIgnoreTemporaryTable();
        }

        public void setIgnoreTemporaryTable(boolean ignoreTemporaryTable) {
                option.setIgnoreTemporaryTable(ignoreTemporaryTable);
        }
        
        public boolean isIgnoreCoordinate() {
                return option.isIgnoreCoordinate();
        }

        public void setIgnoreCoordinate(boolean ignoreCoordinate) {
                option.setIgnoreCoordinate(ignoreCoordinate);
        }

        public void setHandleListener(DataFlowHandleListener listener) {
                option.setHandleListener(listener);
        }

        public void setSqlEnv(TSQLEnv sqlenv) {
                this.sqlenv = sqlenv;
        }

        public void setOption(Option option) {
                this.option = option;
                ModelBindingManager.setGlobalOption(this.option);
        }

        public Option getOption() {
                return option;
        }

        /**
         * Create a parser carrying the syntax compatibility options owned by this
         * analyzer. All primary and nested SQL parsing paths must use this method.
         */
        private TGSqlParser createSqlParser(EDbVendor vendor) {
                TGSqlParser sqlparser = new TGSqlParser(vendor);
                sqlparser.setEnableMssqlColonBindVariables(
                                option != null && option.isMssqlColonBindVariablesEnabled());
                if (sqllrProducerMode()) {
                        // SQL-LR production: an EXACT_MATCH must never be a guess between candidates, whatever the
                        // thread's or the JVM's resolver defaults are (plan 06, Section 3.1).
                        gudusoft.gsqlparser.resolver2.TSQLResolverConfig sqllrConfig =
                                        new gudusoft.gsqlparser.resolver2.TSQLResolverConfig();
                        sqllrConfig.setGuessColumnStrategy(
                                        gudusoft.gsqlparser.resolver2.TSQLResolverConfig.GUESS_COLUMN_STRATEGY_NOT_PICKUP);
                        sqllrConfig.setAllowGuessWhenAllInferred(false);
                        sqlparser.setResolver2Config(sqllrConfig);
                        sqlparser.setResolverType(gudusoft.gsqlparser.EResolverType.RESOLVER2);
                }
                // Every parse this analysis performs — the primary script, nested/dynamic SQL, cross-file
                // units — runs under the analysis's own configuration. A single parser left on the vendor
                // default would resolve one statement by different rules than the rest of the run.
                //
                // Matched against the parser's EFFECTIVE vendor, not the requested one: TGSqlParser maps
                // dbvazuresql onto dbvmssql in its constructor, so those are not always the same value.
                IdentifierProfile profile = identifierProfileFor(sqlparser.getDbVendor());
                if (profile != null) {
                        sqlparser.setIdentifierProfile(profile);
                        return sqlparser;
                }
                IdentifierProfile stated = option != null ? option.getIdentifierProfile() : null;
                if (stated != null && stated.getVendor() == vendor && sqlparser.getDbVendor() != vendor) {
                        // The caller configured a vendor this parser renames. Applying the configuration to the
                        // catalog and the lineage model but not to the parse would leave the analysis keying
                        // names two ways, which is the half-migration that produces a confident wrong answer
                        // with nothing to notice it. Say so instead.
                        throw new IllegalStateException("DataFlowAnalyzer: an identifier profile for "
                                        + vendor + " cannot configure the parse, because TGSqlParser analyzes " + vendor
                                        + " as " + sqlparser.getDbVendor() + ". Build the profile for "
                                        + sqlparser.getDbVendor() + " instead.");
                }
                return sqlparser;
        }

        /**
         * The parser of the analysis's own SQL: {@link #createSqlParser}, recovering T-SQL routines whose body holds a
         * statement it cannot parse when the option asks for it ({@link Option#isRecoverRoutineBodyErrors()}). The
         * recovery stops there: SQL parsed on the way -- dynamic SQL, routines found elsewhere -- is parsed as written,
         * so its diagnostics and its dynamic SQL outcome stay what they were.
         */
        private TGSqlParser createPrimarySqlParser(EDbVendor vendor) {
                TGSqlParser sqlparser = createSqlParser(vendor);
                sqlparser.setRecoverRoutineBodyErrors(option != null && option.isRecoverRoutineBodyErrors());
                return sqlparser;
        }

        /**
         * This analysis's configuration when it applies to {@code vendor}, else null.
         *
         * <p>Nested SQL can carry another dialect (Power Query inner queries, dynamic SQL analyzed as
         * a different vendor). A profile belongs to one vendor, so it is not transplanted onto another
         * one — that parse uses its own vendor's default rather than a mismatched configuration.
         */
        private IdentifierProfile identifierProfileFor(EDbVendor vendor) {
                IdentifierProfile profile = frozenIdentifierProfile != null
                                ? frozenIdentifierProfile
                                : (option != null ? option.getIdentifierProfile() : null);
                return profile != null && profile.getVendor() == vendor ? profile : null;
        }

        /**
         * Choose this analysis's identifier configuration once, before any catalog write, parse or
         * model key.
         *
         * <p>Three inputs can state it — the {@link Option}, a {@link TSQLEnv} handed in by the caller
         * through {@link #setSqlEnv(TSQLEnv)}, and the vendor default. They are reconciled here rather
         * than by each consumer: an environment's catalog is already indexed under its own profile, so
         * an option that disagrees with it is a configuration error, not something to resolve by
         * letting one side win silently.
         */
        private void freezeIdentifierProfile() {
                IdentifierProfile fromOption = option != null ? option.getIdentifierProfile() : null;
                if (fromOption != null && option.getVendor() != null
                                && fromOption.getVendor() != option.getVendor()) {
                        throw new IllegalStateException("DataFlowAnalyzer: identifier profile is for vendor "
                                        + fromOption.getVendor() + " but the option's vendor is " + option.getVendor());
                }
                IdentifierProfile fromEnv = sqlenv != null ? sqlenv.getIdentifierProfile() : null;
                if (fromOption != null && fromEnv != null && !fromOption.hasSameEffectivePolicyAs(fromEnv)) {
                        throw new IllegalStateException("DataFlowAnalyzer: identifier configuration conflict -"
                                        + " Option.setIdentifierProfile() says " + fromOption
                                        + " but the TSQLEnv passed to setSqlEnv() was built with " + fromEnv
                                        + ". A populated environment cannot be re-keyed; build the environment with"
                                        + " the intended profile instead.");
                }
                IdentifierProfile resolved = fromOption != null ? fromOption : fromEnv;
                if (resolved == null) {
                        EDbVendor vendor = option != null ? option.getVendor() : null;
                        if (vendor == null) {
                                return;
                        }
                        resolved = IdentifierProfile.forVendor(vendor, IdentifierProfile.VendorFlags.defaults());
                }
                this.frozenIdentifierProfile = resolved;
                this.frozenIdentifierService = IdentifierService.forProfile(resolved);
        }

        /**
         * The frozen identifier service of this analysis, or null before
         * {@link #freezeIdentifierProfile()} ran.
         *
         * @return the analysis's single comparison engine
         */
        public IdentifierService getIdentifierService() {
                return frozenIdentifierService;
        }

        /**
         * The frozen identifier configuration of this analysis, or null before it was resolved.
         *
         * @return the effective identifier profile of this run
         */
        public IdentifierProfile getIdentifierProfile() {
                return frozenIdentifierProfile;
        }

        public synchronized String chechSyntax() {
                StringBuilder builder = new StringBuilder();
                if (sqlInfos != null) {
                        for (SqlInfo sqlInfo : sqlInfos) {
                                String content = sqlInfo.getSql();
                                if (content != null && content.indexOf("<dlineage") != -1) {
                                        try {
                                                XML2Model.loadXML(dataflow.class, content);
                                                continue;
                                        } catch (Exception e) {
                                                builder.append("Parsing dataflow ").append("occurs errors.\n").append(e.getMessage())
                                                                .append("\n");
                                        }
                                }
                                if (content != null && content.trim().startsWith("{")) {
                                        Map queryObject = (Map) JSON.parseObject(content);
                                        if (isSourceUnavailable(queryObject)) {
                                                continue; // DDL body not retrieved; its text is not the definition
                                        }
                                        content = (String) queryObject.get("sourceCode");
                                }
                                if (MetadataReader.isMetadata(content)) {
                                        continue;
                                }
                                TGSqlParser sqlparser = createPrimarySqlParser(option.getVendor());
                                sqlparser.sqltext = content;
                                int result = sqlparser.parse();
                                if (result != 0) {
                                        builder.append("Parsing sql ").append("occurs errors.\n").append(sqlparser.getErrormessage())
                                                        .append("\n");
                                }
                                // statements routine recovery skipped are still syntax errors of this SQL
                                for (TSyntaxError error : sqlparser.getRecoveredSyntaxErrors()) {
                                        builder.append("Parsing sql occurs errors (").append(skippedStatement(sqlparser, error))
                                                        .append(" skipped, rest of the routine analyzed).\n")
                                                        .append(getErrorMessage(error, ErrorInfo.SYNTAX_ERROR)).append("\n");
                                }
                        }
                }
                return builder.toString();
        }

        public synchronized String generateDataFlow(boolean withExtraInfo) {
                // Gated here as well as in TGSqlParser.parse(), which this reaches
                // transitively: refusing at the API boundary gives the caller a clear
                // failure instead of one surfacing from deep inside the analysis.
                gudusoft.gsqlparser.runtime.GspRuntime.requireActivated();
                authoritativeLineageEvidence = AuthoritativeLineageEvidence.empty();
                if (option.isAutoDetectLargeFile()) {
                        LargeFileDetector.LargeFileDetectionResult result = LargeFileDetector.detect(sqlInfos, originalFiles, option);
                        if (result.shouldDelegate && delegateToParallel(result)) {
                                return finishGenerateDataFlow(withExtraInfo);
                        }
                }

                if (ModelBindingManager.get() == null) {
                        ModelBindingManager.set(modelManager);
                }

                // Choose the configuration ONCE, then publish it for the whole run and put back whatever
                // was there before. Save/restore rather than a bare set: an outer analysis on this thread
                // (nested dlineage, a pooled worker) must find its own rules again, on the exception path
                // as well as the normal one.
                freezeIdentifierProfile();
                IdentifierService previousService = ModelBindingManager.getGlobalIdentifierServiceRaw();
                if (frozenIdentifierService != null) {
                        ModelBindingManager.setGlobalIdentifierService(frozenIdentifierService);
                }
                try {
                        initPipelinedFunctionAnalyzer();

                        dataflow = analyzeSqlScript();

                        return finishGenerateDataFlow(withExtraInfo);
                } finally {
                        ModelBindingManager.setGlobalIdentifierService(previousService);
                }
        }

        private boolean delegateToParallel(LargeFileDetector.LargeFileDetectionResult result) {
                ParallelDataFlowAnalyzer parallelAnalyzer = null;
                //autogenerate 委托路径产生的拆分目录、gsp-input 临时文件及拆分产物统一在此清理
                File splitDir = new File(System.getProperty("java.io.tmpdir"), "gsp-split-" + UUID.randomUUID().toString());
                if (!splitDir.exists() && !splitDir.mkdirs()) {
                        logger.error("Failed to create split directory: " + splitDir.getAbsolutePath());
                        return false;
                }
                try {
                        logger.info("Delegating to ParallelDataFlowAnalyzer: " + result.reason);

                        parallelAnalyzer = buildParallelAnalyzer(splitDir);
                        parallelAnalyzer.setSqlEnv(sqlenv);

                        parallelAnalyzer.generateDataFlow(false, true);

                        this.dataflow = parallelAnalyzer.getDataFlow();
                        this.dataflowString = null;
                        this.errorInfos.clear();
                        this.errorInfos.addAll(parallelAnalyzer.getErrorMessages());
                        this.sqlInfoMap = (IndexedLinkedHashMap<String, List<SqlInfo>>) parallelAnalyzer.getSqlInfos();

                        return true;
                } catch (Exception e) {
                        logger.error("Delegation to ParallelDataFlowAnalyzer failed, falling back to single-threaded", e);
                        return false;
                } finally {
                        //autogenerate dispose 异常不能阻塞 splitDir 清理，避免临时产物残留
                        if (parallelAnalyzer != null) {
                                try {
                                        parallelAnalyzer.dispose();
                                } catch (Exception ex) {
                                        logger.error("Failed to dispose parallel analyzer", ex);
                                }
                        }
                        //autogenerate 清理委托路径产生的拆分目录、gsp-input 临时文件及拆分产物，成功或失败均必须执行
                        SQLUtil.deltree(splitDir);
                }
        }

        private ParallelDataFlowAnalyzer buildParallelAnalyzer(File splitDir) {
                if (originalFiles != null) {
                        return new ParallelDataFlowAnalyzer(originalFiles, option,
                                        option.getLargeFileSplitSizeMB(), splitDir);
                }
                // SqlInfo[] constructor path: collect files from all entries. Entries
                // without a filePath (e.g., String/String[] constructors, or large
                // raw SQL strings) are written to temp files so they can be split.
                // All paths must go through split, otherwise ParallelDataFlowAnalyzer
                // would create DataFlowAnalyzer instances internally which would
                // detect the same large input and delegate again → infinite recursion.
                if (sqlInfos != null && sqlInfos.length > 0) {
                        List<File> files = new ArrayList<>();
                        for (SqlInfo info : sqlInfos) {
                                if (info == null) continue;
                                File f = null;
                                if (info.getFilePath() != null) {
                                        f = new File(info.getFilePath());
                                }
                                if (f != null && f.exists()) {
                                        if (!files.contains(f)) {
                                                files.add(f);
                                        }
                                } else if (info.getSql() != null) {
                                        try {
                                                f = File.createTempFile("gsp-input-", ".tmp", splitDir);
                                                try (FileWriter fw = new FileWriter(f)) {
                                                        fw.write(info.getSql());
                                                }
                                                files.add(f);
                                        } catch (Exception e) {
                                                logger.error("Failed to create temp file for split", e);
                                        }
                                }
                        }
                        if (!files.isEmpty()) {
                                return new ParallelDataFlowAnalyzer(files.toArray(new File[0]), option,
                                                option.getLargeFileSplitSizeMB(), splitDir);
                        }
                }
                return new ParallelDataFlowAnalyzer(sqlInfos, option);
        }

        private String finishGenerateDataFlow(boolean withExtraInfo) {
                if (dataflow != null && frozenIdentifierProfile != null) {
                        // Same-run provenance, so a later in-memory merge can tell whether two results were
                        // produced under the same rules instead of guessing from display names. Transient:
                        // it does not enter the XML, and it is gone after a round-trip (see dataflow).
                        dataflow.setIdentifierPolicy(frozenIdentifierProfile);
                }
                if (dataflow != null && !withExtraInfo && dataflow.getResultsets() != null) {
                        for (table t : dataflow.getResultsets()) {
                                t.setIsTarget(null);
                t.setProcedureId(null);
                                if (t.getColumns() != null) {
                                        for (column t1 : t.getColumns()) {
                                                t1.setIsFunction(null);
                                        }
                                }
                        }
                }

        if (dataflow != null && !withExtraInfo && dataflow.getVariables() != null) {
            for (table t : dataflow.getVariables()) {
                t.setIsTarget(null);
                t.setProcedureId(null);
            }
        }

                if(dataflow!=null && dataflow.getRelationships()!=null && option.getFilterRelationTypes()!=null && !option.getFilterRelationTypes().isEmpty()) {
                        List<relationship> relationships = new ArrayList<relationship>();
                        for(relationship relationship: dataflow.getRelationships()) {
                                if(option.getFilterRelationTypes().contains(relationship.getType())) {
                                        relationships.add(relationship);
                                }
                        }
                        dataflow.setRelationships(relationships);
                }

                CommentBindingProjection.retain(dataflow);
        if (option.getHandleListener() != null) {
                        option.getHandleListener().endAnalyze(dataflow);
                }

                if (option.isOutput()) {
                        if (option.getHandleListener() != null) {
                                option.getHandleListener().startOutputDataFlowXML();
                        }
                        if (dataflow != null) {
                                if (option.isTextFormat()) {
                                        dataflowString = getTextOutput(dataflow);
                                } else {
                                        try {
                                                dataflowString = XML2Model.saveXML(dataflow);
                                        }catch (Exception e){
                                                logger.error("Output dataflow to xml failed.", e);
                                                dataflowString = null;
                                        }
                                }
                        }
                        if (option.getHandleListener() != null) {
                                option.getHandleListener().endOutputDataFlowXML(dataflowString == null ? 0 : dataflowString.length());
                        }
                }

                return dataflowString;
        }

        private dataflow removeDuplicateColumns(dataflow dataflow) {
                List<table> tables = new ArrayList<table>();
                if (dataflow.getTables() != null) {
                        tables.addAll(dataflow.getTables());
                }
                if (dataflow.getViews() != null) {
                        tables.addAll(dataflow.getViews());
                }
                if (dataflow.getStages() != null) {
                        tables.addAll(dataflow.getStages());
                }
                if (dataflow.getDatasources() != null) {
                        tables.addAll(dataflow.getDatasources());
                }
                if (dataflow.getStreams() != null) {
                        tables.addAll(dataflow.getStreams());
                }
                if (dataflow.getPaths() != null) {
                        tables.addAll(dataflow.getPaths());
                }
                if (dataflow.getVariables() != null) {
                        tables.addAll(dataflow.getVariables());
                }
                if (dataflow.getResultsets() != null) {
                        tables.addAll(dataflow.getResultsets());
                }
                for (table table : tables) {
                        if (table.getColumns() == null) {
                                continue;
                        }
                        Set<String> columnIds = new HashSet<String>();
                        Iterator<column> iter = table.getColumns().iterator();
                        while(iter.hasNext()) {
                                column column = iter.next();
                                String id = column.getId();
                                if (columnIds.contains(id)) {
                                        iter.remove();
                                } else {
                                        columnIds.add(id);
                                }
                        }
                }
                return dataflow;
        }

        public synchronized String generateDataFlow() {
                return generateDataFlow(false);
        }

        public synchronized String generateSqlInfos() {
                return JSON.toJSONString(sqlInfoMap);
        }

        public Map<String, List<SqlInfo>> getSqlInfos() {
                return sqlInfoMap;
        }

        public Map getHashSQLMap() {
                return modelManager.getHashSQLMap();
        }
        
        public Map getDynamicSQLMap() {
                return modelManager.getDynamicSQLMap();
        }

        /**
         * @deprecated please use SqlInfoHelper.getSelectedDbObjectInfo
         */
        public DbObjectPosition getSelectedDbObjectInfo(Coordinate start, Coordinate end) {
                if (start == null || end == null) {
                        throw new IllegalArgumentException("Coordinate can't be null.");
                }

                String hashCode = start.getHashCode();

                if (hashCode == null) {
                        throw new IllegalArgumentException("Coordinate hashcode can't be null.");
                }

                int dbObjectStartLine = (int) start.getX() - 1;
                int dbObjectStarColumn = (int) start.getY() - 1;
                int dbObjectEndLine = (int) end.getX() - 1;
                int dbObjectEndColumn = (int) end.getY() - 1;
                List<SqlInfo> sqlInfoList;
                if (hashCode.matches("\\d+")) {
                        sqlInfoList = sqlInfoMap.getValueAtIndex(Integer.valueOf(hashCode));
                } else {
                        sqlInfoList = sqlInfoMap.get(hashCode);
                }
                for (int j = 0; j < sqlInfoList.size(); j++) {
                        SqlInfo sqlInfo = sqlInfoList.get(j);
                        int startLine = sqlInfo.getLineStart();
                        int endLine = sqlInfo.getLineEnd();
                        if (dbObjectStartLine >= startLine && dbObjectStartLine <= endLine) {
                                DbObjectPosition position = new DbObjectPosition();
                                position.setFile(sqlInfo.getFileName());
                                position.setFilePath(sqlInfo.getFilePath());
                                position.setSql(sqlInfo.getSql());
                                position.setIndex(sqlInfo.getOriginIndex());
                                List<Pair<Integer, Integer>> positions = position.getPositions();
                                positions.add(new Pair<Integer, Integer>(
                                                dbObjectStartLine - startLine + sqlInfo.getOriginLineStart() + 1, dbObjectStarColumn + 1));
                                positions.add(new Pair<Integer, Integer>(dbObjectEndLine - startLine + sqlInfo.getOriginLineStart() + 1,
                                                dbObjectEndColumn + 1));
                                return position;
                        }
                }
                return null;
        }

        /**
         * 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,&lt;n&gt;,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.
         */
        private static boolean hasUsableCoordinate(String coordinate) {
                return DlineageUtil.hasUsableCoordinate(coordinate);
        }

        public static dataflow mergeTables(dataflow dataflow, Long startId) {
                return mergeTables(dataflow, startId, new Option());
        }

        public static dataflow mergeTables(dataflow dataflow, Long startId, Option option) {
                List<table> tableCopy = new ArrayList<table>();
                List<table> viewCopy = new ArrayList<table>();
                List<table> databaseCopy = new ArrayList<table>();
                List<table> schemaCopy = new ArrayList<table>();
                List<table> stageCopy = new ArrayList<table>();
                List<table> dataSourceCopy = new ArrayList<table>();
                List<table> streamCopy = new ArrayList<table>();
                List<table> fileCopy = new ArrayList<table>();
                List<table> variableCopy = new ArrayList<table>();
                List<table> cursorCopy = new ArrayList<table>();
                List<table> resultSetCopy = new ArrayList<table>();
                if (dataflow.getTables() != null) {
                        tableCopy.addAll(dataflow.getTables());
                }
                dataflow.setTables(tableCopy);
                if (dataflow.getViews() != null) {
                        viewCopy.addAll(dataflow.getViews());
                }
                dataflow.setViews(viewCopy);
                if (dataflow.getDatabases() != null) {
                        databaseCopy.addAll(dataflow.getDatabases());
                }
                dataflow.setDatabases(databaseCopy);
                if (dataflow.getSchemas() != null) {
                        schemaCopy.addAll(dataflow.getSchemas());
                }
                dataflow.setSchemas(schemaCopy);
                if (dataflow.getStages() != null) {
                        stageCopy.addAll(dataflow.getStages());
                }
                dataflow.setStages(stageCopy);
                if (dataflow.getDatasources() != null) {
                        dataSourceCopy.addAll(dataflow.getDatasources());
                }
                dataflow.setDatasources(dataSourceCopy);
                if (dataflow.getStreams() != null) {
                        streamCopy.addAll(dataflow.getStreams());
                }
                dataflow.setStreams(streamCopy);
                if (dataflow.getPaths() != null) {
                        fileCopy.addAll(dataflow.getPaths());
                }
                dataflow.setPaths(fileCopy);
                if (dataflow.getVariables() != null) {
                        variableCopy.addAll(dataflow.getVariables());
                }
                dataflow.setVariables(variableCopy);
                if (dataflow.getResultsets() != null) {
                        resultSetCopy.addAll(dataflow.getResultsets());
                }
                dataflow.setResultsets(resultSetCopy);

                Map<Object, List<table>> tableMap = new HashMap<Object, List<table>>();
                Map<Object, String> tableTypeMap = new HashMap<Object, String>();
                Map<String, TMssqlCreateType> mssqlTypeMap = new HashMap<String, TMssqlCreateType>();
                Map<String, String> tableIdMap = new HashMap<String, String>();

                Map<Object, List<column>> columnMap = new HashMap<Object, List<column>>();
                Map<Object, Set<Object>> tableColumnMap = new HashMap<Object, Set<Object>>();
                Map<String, String> columnIdMap = new HashMap<String, String>();
                Map<String, column> columnMergeIdMap = new HashMap<String, column>();
                // columns of one table renamed apart because their names collide across identities, by column id
                Map<String, String> renamedColumns = new HashMap<String, String>();

                List<table> tables = new ArrayList<table>();
                tables.addAll(dataflow.getTables());
                tables.addAll(dataflow.getViews());
                tables.addAll(dataflow.getDatabases());
                tables.addAll(dataflow.getSchemas());
                tables.addAll(dataflow.getStages());
                tables.addAll(dataflow.getDatasources());
                tables.addAll(dataflow.getStreams());
                tables.addAll(dataflow.getPaths());
                tables.addAll(dataflow.getResultsets());
                tables.addAll(dataflow.getVariables());
                
                Set<String> columnIds = new HashSet<String>();

                // Physical tables and views that share a legacy folded name but are different tables under
                // the analysis's identifier rules must not merge into one output table.
                Set<table> physicalTables = Collections.newSetFromMap(new IdentityHashMap<table, Boolean>());
                physicalTables.addAll(dataflow.getTables());
                physicalTables.addAll(dataflow.getViews());
                Map<table, String> legacyTableKeys = new IdentityHashMap<table, String>();
                for (table table : tables) {
                        legacyTableKeys.put(table, LegacyDlineageWireNamesV1.tableBucket(DlineageUtil.getQualifiedTableName(table)));
                }
                // Decided per legacy bucket once every table of the merge is known, so the result does not
                // depend on the order the tables arrive in.
                PhysicalTableMergeKeys mergeKeys = new PhysicalTableMergeKeys(DlineageUtil.configuresIdentifierRules());
                for (table table : tables) {
                        if (table.getIdentifierKey() == null && physicalTables.contains(table)) {
                                String qualifiedTableName = DlineageUtil.getQualifiedTableName(table);
                                mergeKeys.addTable(table, legacyTableKeys.get(table), qualifiedTableName);
                        }
                }

                for (table table : tables) {
                        String qualifiedTableName = DlineageUtil.getQualifiedTableName(table);
                        Object tableFullName = table.getIdentifierKey() != null ? table.getIdentifierKey()
                                        : legacyTableKeys.get(table);
                        if (table.getIdentifierKey() == null && physicalTables.contains(table)) {
                                tableFullName = mergeKeys.keyOf((String) tableFullName,
                                                PhysicalTableMergeKeys.carriedIdentity(table, (String) tableFullName, qualifiedTableName),
                                                qualifiedTableName);
                        }
                        if ("variable".endsWith(table.getType()) && !SQLUtil.isEmpty(table.getParent())) {
                                tableFullName = table.getParent() + "." + tableFullName;
                        }
                        if (table.isScopedTemporary()) {
                                // One routine body's temporary table is not the same table as another of its name.
                                tableFullName = Arrays.asList("scoped temporary table", table.getId());
                        }
                        if (table.isArrayRelation()) {
                                // A LATERAL VIEW's relation is not the table of the script that has its name (Mantis 4890).
                                tableFullName = Arrays.asList("array relation", table.getId());
                        }
                        if (table.isFile() && (table.getDataSourceName() != null || table.getEndpointKind() != null)) {
                                // A file a BULK INSERT names relative to an external data source, or a runtime template, is not
                                // the file of its name elsewhere (Mantis 4962).
                                tableFullName = Arrays.asList("path", tableFullName, table.getUri(), table.getDataSourceName(),
                                                table.getEndpointKind());
                        }

                        if (!tableMap.containsKey(tableFullName)) {
                                tableMap.put(tableFullName, new ArrayList<table>());
                        }

                        tableMap.get(tableFullName).add(table);

                        if (!tableTypeMap.containsKey(tableFullName)) {
                                tableTypeMap.put(tableFullName, table.getType());
                        } else if ("view".equals(table.getSubType())) {
                                tableTypeMap.put(tableFullName, table.getType());
                        } else if ("database".equals(table.getSubType())) {
                                tableTypeMap.put(tableFullName, table.getType());
                        } else if ("schema".equals(table.getSubType())) {
                                tableTypeMap.put(tableFullName, table.getType());
                        } else if ("stage".equals(table.getSubType())) {
                                tableTypeMap.put(tableFullName, table.getType());
                        } else if ("sequence".equals(table.getSubType())) {
                                tableTypeMap.put(tableFullName, table.getType());
                        } else if ("datasource".equals(table.getSubType())) {
                                tableTypeMap.put(tableFullName, table.getType());
                        } else if ("stream".equals(table.getSubType())) {
                                tableTypeMap.put(tableFullName, table.getType());
                        } else if ("file".equals(table.getSubType())) {
                                tableTypeMap.put(tableFullName, table.getType());
                        } else if ("table".equals(tableTypeMap.get(tableFullName))) {
                                tableTypeMap.put(tableFullName, table.getType());
                        } else if ("variable".equals(tableTypeMap.get(tableFullName))) {
                                tableTypeMap.put(tableFullName, table.getType());
                        }

                        if (table.getColumns() != null) {
                                if (!tableColumnMap.containsKey(tableFullName)) {
                                        tableColumnMap.put(tableFullName, new LinkedHashSet<Object>());
                                }
                                for (column column : table.getColumns()) {
                                        String columnSuffix = (column.getQualifiedTable() != null
                                                                        ? (LegacyDlineageWireNamesV1.tableBucket(column.getQualifiedTable()) + ".")
                                                                        : "")
                                                        + ("false".equals(table.getIsTarget()) ? LegacyDlineageWireNamesV1.columnSegmentBucket(column.getName())
                                                                        : LegacyDlineageWireNamesV1.columnBucket(column.getName()));
                                        Object columnFullName = table.getIdentifierKey() != null
                                                        ? java.util.Arrays.asList(tableFullName, columnSuffix) : tableFullName + "." + columnSuffix;
                                        if (column.getIdentifierKey() != null) {
                                                columnFullName = java.util.Arrays.asList(tableFullName, column.getQualifiedTable(),
                                                                column.getIdentifierKey());
                                        } else if (column.getFieldPathKey() != null) {
                                                // a STRUCT field path node, by its declared column and path (plan section 4.7)
                                                columnFullName = java.util.Arrays.asList(tableFullName, column.getQualifiedTable(),
                                                                column.getFieldPathKey());
                                        }

                                        if (!columnMap.containsKey(columnFullName)) {
                                                columnMap.put(columnFullName, new ArrayList<column>());
                                                tableColumnMap.get(tableFullName).add(columnFullName);
                                        }

                                        columnMap.get(columnFullName).add(column);
                                        columnIds.add(column.getId());
                                }
                        }
                }

                Set<String> relationParentIds = new HashSet<String>();
                if (dataflow.getRelationships() != null) {
                        for (relationship rel : dataflow.getRelationships()) {
                                if (rel.getSources() != null) {
                                        for (sourceColumn src : rel.getSources()) {
                                                if (src.getParent_id() != null) {
                                                        relationParentIds.add(src.getParent_id());
                                                }
                                        }
                                }
                                if (rel.getTarget() != null) {
                                        if (rel.getTarget().getParent_id() != null) {
                                                relationParentIds.add(rel.getTarget().getParent_id());
                                        }
                                }
                        }
                }

                Iterator<Object> tableNameIter = tableMap.keySet().iterator();
                while (tableNameIter.hasNext()) {
                        Object tableName = tableNameIter.next();
                        List<table> tableList = tableMap.get(tableName);
                        table table;
                        if (tableList.size() > 1) {
                                DataflowUtility.GroupNames chosen = DataflowUtility.groupNames(tableList);
                                table standardTable = chosen.displayed;
                                // Function允许重名，不做合并处理
                                if (standardTable.isFunction()) {
                                        continue;
                                }
                                
                                // Variable允许重名，不做合并处理
                                if (standardTable.isVariable()) {
                                        continue;
                                }
                                
                                // 临时表不做合并处理
                                if(SQLUtil.isTempTable(standardTable)) {
                                        continue;
                                }

                                String type = tableTypeMap.get(tableName);
                                table = new table();
                                table.setId(String.valueOf(++startId));
                                table names = chosen.names;
                                table.setServer(names.getServer());
                                table.setDatabase(names.getDatabase());
                                table.setSchema(names.getSchema());
                                table.setName(names.getName());
                                table.setIdentifierKey(standardTable.getIdentifierKey());
                                DataflowUtility.carryGroupIdentity(table, tableList, chosen);
                                table.setDisplayName(names.getDisplayName());
                                table.setParent(standardTable.getParent());
                                table.setMore(standardTable.getMore());
                                if (standardTable.getCandidateTables() != null && !standardTable.getCandidateTables().isEmpty()) {
                                        table.setCandidateTables(new ArrayList<String>(standardTable.getCandidateTables()));
                                }
                                table.setColumns(new ArrayList<column>());
                                String subType = null;
                                for(table item: tableList){
                                        if (item.getSubType() != null) {
                                                subType = item.getSubType();
                                                break;
                                        }
                                }
                                if (subType != null) {
                                        table.setSubType(subType);
                                } else {
                                        table.setSubType(standardTable.getSubType());
                                }
                                Set<String> processIds = new LinkedHashSet<String>();
                                for (int k = 0; k < tableList.size(); k++) {
                                        if (tableList.get(k).getProcessIds() != null) {
                                                processIds.addAll(tableList.get(k).getProcessIds());
                                        }
                                }
                                if (!processIds.isEmpty()) {
                                        table.setProcessIds(new ArrayList<String>(processIds));
                                }
                                Set<String> alias = new LinkedHashSet<String>();
                                for (int k = 0; k < tableList.size(); k++) {
                                        if (tableList.get(k).getAlias() != null) {
                                                alias.addAll(Arrays.asList(tableList.get(k).getAlias().split("\\s*,\\s*")));
                                        }
                                }
                                if (!alias.isEmpty()) {
                                        String aliasString = Arrays.toString(alias.toArray(new String[0]));
                                        table.setAlias(aliasString.substring(1, aliasString.length() - 1));
                                }
                                table.setType(type);
                                if (tableName instanceof List && "path".equals(((List<?>) tableName).get(0))) {
                                        // one file under one identity (above): what tells it apart stays on it
                                        table.setUri(standardTable.getUri());
                                        table.setDataSourceName(standardTable.getDataSourceName());
                                        table.setEndpointKind(standardTable.getEndpointKind());
                                        table.setTemplatedParts(standardTable.getTemplatedParts());
                                }
                                for (table item : tableList) {
                                        if (!SQLUtil.isEmpty(table.getCoordinate()) && !SQLUtil.isEmpty(item.getCoordinate())) {
                                                if (table.getCoordinate().indexOf(item.getCoordinate()) == -1) {
                                                        table.appendCoordinate(item.getCoordinate());
                                                }
                                        } else if (!SQLUtil.isEmpty(item.getCoordinate())) {
                                                table.setCoordinate(item.getCoordinate());
                                        }

                                        if (item.getStarStmt() != null) {
                                                table.setStarStmt(item.getStarStmt());
                                        }

                                        tableIdMap.put(item.getId(), table.getId());

                                        if (item.isView()) {
                                                dataflow.getViews().remove(item);
                                        } else if (item.isDatabaseType()) {
                                                dataflow.getDatabases().remove(item);
                                        } else if (item.isSchemaType()) {
                                                dataflow.getSchemas().remove(item);
                                        } else if (item.isStage()) {
                                                dataflow.getStages().remove(item);
                                        } else if (item.isDataSource()) {
                                                dataflow.getDatasources().remove(item);
                                        } else if (item.isStream()) {
                                                dataflow.getStreams().remove(item);
                                        } else if (item.isFile()) {
                                                dataflow.getPaths().remove(item);
                                        } else if (item.isVariable()) {
                                                dataflow.getVariables().remove(item);
                                        } else if (item.isTable()) {
                                                dataflow.getTables().remove(item);
                                        } else if (item.isResultSet()) {
                                                dataflow.getResultsets().remove(item);
                                        }
                                }

                                if (table.isView()) {
                                        dataflow.getViews().add(table);
                                } else if (table.isDatabaseType()) {
                                        dataflow.getDatabases().add(table);
                                } else if (table.isSchemaType()) {
                                        dataflow.getSchemas().add(table);
                                } else if (table.isStage()) {
                                        dataflow.getStages().add(table);
                                } else if (table.isDataSource()) {
                                        dataflow.getDatasources().add(table);
                                } else if (table.isStream()) {
                                        dataflow.getStreams().add(table);
                                } else if (table.isFile()) {
                                        dataflow.getPaths().add(table);
                                } else if (table.isVariable()) {
                                        dataflow.getVariables().add(table);
                                } else if (table.isResultSet()) {
                                        dataflow.getResultsets().add(table);
                                } else {
                                        dataflow.getTables().add(table);
                                }
                        } else {
                                table = tableList.get(0);
                                if(Boolean.TRUE.toString().equals(table.getIsDetermined())){
                                        continue;
                                }
                                
                                if (option.isIgnoreUnusedSynonym() && SubType.synonym.name().equals(table.getSubType())) {
                                        boolean hasSourceRelation = relationParentIds.contains(table.getId());
                                        if (!hasSourceRelation) {
                                                dataflow.getTables().remove(table);
                                                tableColumnMap.get(tableName).clear();
                                                continue;
                                        }
                                }
                        }

                        Set<Object> columns = tableColumnMap.get(tableName);
                        Iterator<Object> columnIter = columns.iterator();
                        List<column> mergeColumns = new ArrayList<column>();
                        while (columnIter.hasNext()) {
                                Object columnName = columnIter.next();
                                List<column> columnList = columnMap.get(columnName);
                                List<column> functions = new ArrayList<column>();
                                for (column t : columnList) {
                                        if (Boolean.TRUE.toString().equals(t.getIsFunction())) {
                                                functions.add(t);
                                        }
                                }
                                if (functions != null && !functions.isEmpty()) {
                                        for (column function : functions) {
                                                mergeColumns.add(function);
                                                columnIdMap.put(function.getId(), function.getId());
                                                columnMergeIdMap.put(function.getId(), function);
                                        }

                                        columnList.removeAll(functions);
                                }
                                if (!columnList.isEmpty()) {
                                        column firstColumn = columnList.iterator().next();
                                        if (columnList.size() > 1) {
                                                column mergeColumn = new column();
                                                mergeColumn.setId(String.valueOf(++startId));
                                                mergeColumn.setName(firstColumn.getName());
                                                mergeColumn.setStar(firstColumn.getStar());
                                                mergeColumn.setIdentifierKey(firstColumn.getIdentifierKey());
                                                mergeColumn.setFieldPathKey(firstColumn.getFieldPathKey());
                                                mergeColumn.setSqlSpelling(DataflowUtility.sqlSpellingOf(columnList));
                                                mergeColumn.setDisplayName(firstColumn.getDisplayName());
                                                mergeColumn.setSource(firstColumn.getSource());
                                                mergeColumn.setQualifiedTable(firstColumn.getQualifiedTable());
                                                mergeColumn.setDataType(firstColumn.getDataType());
                                                mergeColumn.setForeignKey(firstColumn.isForeignKey());
                                                mergeColumn.setPrimaryKey(firstColumn.isPrimaryKey());
                                                mergeColumn.setUnqiueKey(firstColumn.isUnqiueKey());
                                                mergeColumn.setIndexKey(firstColumn.isIndexKey());
                                                mergeColumns.add(mergeColumn);
                                                for (column item : columnList) {
                                                        mergeColumn.appendCoordinate(item.getCoordinate());
                                                        columnIdMap.put(item.getId(), mergeColumn.getId());
                                                }
                                                columnMergeIdMap.put(mergeColumn.getId(), mergeColumn);
                                                columnIds.add(mergeColumn.getId());
                                        } else {
                                                mergeColumns.add(firstColumn);
                                                columnIdMap.put(firstColumn.getId(), firstColumn.getId());
                                                columnMergeIdMap.put(firstColumn.getId(), firstColumn);
                                        }
                                }
                        }
                        table.setColumns(mergeColumns);
                        if (Column.starLinksGroupedByIdentity()) {
                                renamedColumns.putAll(DataflowUtility.nameCollidingIdentities(mergeColumns,
                                                option.getVendor() != null ? option.getVendor() : ModelBindingManager.getGlobalVendor()));
                        }
                }

                Map<String, String> commentRelationIds = dataflow.getCommentBindings() == null ? null : new HashMap<String, String>();
        if (dataflow.getRelationships() != null) {
                        Map<Long, relationship> mergeRelations = new LinkedHashMap<Long, relationship>();
                        // A synonym relationship states a catalog fact between two columns, and two producers can state the
                        // same one (the metadata reader from the synonym list, the catalog synonym materializer for a synonym
                        // the SQL reads). Once the merged ids decide the columns, a repeat of the same columns is one fact;
                        // the relationship's display names and coordinates, which the two producers spell differently, do not
                        // make it another.
                        Map<List<String>, relationship> synonymRelations = new HashMap<List<String>, relationship>();
                        for (int i = 0; i < dataflow.getRelationships().size(); i++) {
                                relationship relation = dataflow.getRelationships().get(i);
                                
                                if("crud".equals(relation.getType()) && option.getAnalyzeMode() == AnalyzeMode.crud) {
                                        long key = relation.toDedupHash();
                                        if (!mergeRelations.containsKey(key)) {
                                                mergeRelations.put(key, relation);
                                        }
                                        continue;
                                }
                                
                                targetColumn target = relation.getTarget();
                                if ("call".equals(relation.getType())) {
                                        target = relation.getCaller();
                                }
                                if (target != null && tableIdMap.containsKey(target.getParent_id())) {
                                        target.setParent_id(tableIdMap.get(target.getParent_id()));
                                }

                                if (columnIdMap.containsKey(target.getId())) {
                                        target.setId(columnIdMap.get(target.getId()));
                                        target.setCoordinate(columnMergeIdMap.get(target.getId()).getCoordinate());
                                }
                                else if(option.isIgnoreUnusedSynonym() && EffectType.synonym.name().equals(relation.getEffectType())){
                                        continue;
                                }
                                
                                if (!"call".equals(relation.getType()) && !columnIds.contains(target.getId())) {
                                        continue;
                                }

                                List<sourceColumn> sources = relation.getSources();
                                if ("call".equals(relation.getType())) {
                                        sources = relation.getCallees();
                                }
                                // Sources of merged columns keep their own reference-site
                                // coordinate (the ON/WHERE operand span) instead of the merged
                                // column's stamped definition coordinate. Source and relation
                                // dedup, however, must still collapse EXACTLY as they did under
                                // the stamped coordinates — sourceColumn.equals and
                                // relationship.toDedupHash both include the coordinate — so the
                                // stamped coordinate is applied for the dedup steps and the
                                // reference-site coordinate is restored on the survivors below.
                                Map<sourceColumn, String> referenceCoordinates = new IdentityHashMap<sourceColumn, String>();
                                Set<sourceColumn> sourceSet = new LinkedHashSet<sourceColumn>();
                                if (sources != null) {
                                        for (sourceColumn source : sources) {
                                                // Reference-published source of an UNMERGED column: stamp
                                                // the definition span it carried before reference-site
                                                // publishing, so dedup keeps its legacy behavior.
                                                String dedupCoordinate = source.getDedupCoordinate();
                                                if (dedupCoordinate != null && !dedupCoordinate.equals(source.getCoordinate())) {
                                                        referenceCoordinates.put(source, source.getCoordinate());
                                                        source.setCoordinate(dedupCoordinate);
                                                }
                                                if (!"call".equals(relation.getType()) && !columnIds.contains(source.getId())) {
                                                        continue;
                                                }
                                                if (tableIdMap.containsKey(source.getParent_id())) {
                                                        source.setParent_id(tableIdMap.get(source.getParent_id()));
                                                }
                                                if (tableIdMap.containsKey(source.getSource_id())) {
                                                        source.setSource_id(tableIdMap.get(source.getSource_id()));
                                                }
                                                if (columnIdMap.containsKey(source.getId())) {
                                                        String ownCoordinate = referenceCoordinates.containsKey(source)
                                                                        ? referenceCoordinates.get(source)
                                                                        : source.getCoordinate();
                                                        source.setId(columnIdMap.get(source.getId()));
                                                        source.setCoordinate(columnMergeIdMap.get(source.getId()).getCoordinate());
                                                        if (hasUsableCoordinate(ownCoordinate)) {
                                                                // The operand's own coordinate survives the merge;
                                                                // only a synthetic/absent one is replaced by the
                                                                // merged column's definition coordinate for good.
                                                                referenceCoordinates.put(source, ownCoordinate);
                                                        } else {
                                                                referenceCoordinates.remove(source);
                                                        }
                                                }
                                        }

                                        sourceSet.addAll(sources);
                                        if ("call".equals(relation.getType())) {
                                                relation.setCallees(new ArrayList<sourceColumn>(sourceSet));
                                        } else {
                                                relation.setSources(new ArrayList<sourceColumn>(sourceSet));
                                        }
                                }

                                if (EffectType.synonym.name().equals(relation.getEffectType()) && target != null
                                                && relation.getSources() != null) {
                                        List<String> synonymKey = new ArrayList<String>();
                                        synonymKey.add(target.getId());
                                        List<String> sourceIds = new ArrayList<String>();
                                        for (sourceColumn source : relation.getSources()) {
                                                sourceIds.add(source.getId());
                                        }
                                        Collections.sort(sourceIds, Comparator.nullsFirst(Comparator.<String>naturalOrder()));
                                        synonymKey.addAll(sourceIds);
                                        relationship stated = synonymRelations.get(synonymKey);
                                        if (stated != null) {
                                                if (commentRelationIds != null) commentRelationIds.put(relation.getId(), stated.getId());
                                                continue;
                                        }
                                        synonymRelations.put(synonymKey, relation);
                                }

                                long key = relation.toDedupHash();
                                if (!mergeRelations.containsKey(key)) {
                                        mergeRelations.put(key, relation);
                                        // Restore the reference-site coordinates on the surviving
                                        // relation's sources, now that dedup ran under the stamped
                                        // legacy coordinates.
                                        for (Map.Entry<sourceColumn, String> entry : referenceCoordinates.entrySet()) {
                                                entry.getKey().setCoordinate(entry.getValue());
                                        }
                                }
                if (commentRelationIds != null) commentRelationIds.put(relation.getId(), mergeRelations.get(key).getId());
                        }

                        dataflow.setRelationships(new ArrayList<relationship>(mergeRelations.values()));
                }

        if (commentRelationIds != null) CommentBindingProjection.remap(dataflow, tableIdMap, columnIdMap, commentRelationIds);
                DataflowUtility.renameEndpoints(dataflow.getRelationships(), renamedColumns);

                tableMap.clear();
                tableTypeMap.clear();
                tableIdMap.clear();
                columnMap.clear();
                tableColumnMap.clear();
                columnIdMap.clear();
                columnMergeIdMap.clear();
                tables.clear();
                return dataflow;
        }

        public synchronized dataflow getDataFlow() {
                if (dataflow != null) {
                        return dataflow;
                } else if (dataflowString != null) {
                        return XML2Model.loadXML(dataflow.class, dataflowString);
                }
                return null;
        }

        /**
         * Returns immutable AST/catalog evidence captured during this analyzer run.
         * The evidence is correlated to {@link #getDataFlow()} by document-local IDs
         * and is intentionally absent from the legacy serialized contract.
         */
        @Override
        public synchronized AuthoritativeLineageEvidence getAuthoritativeLineageEvidence() {
                return authoritativeLineageEvidence;
        }

        /**
         * Binds a SQL-LR observation recorder to this analysis, before {@link #generateDataFlow()}. Internal API of the
         * SQL-LR producer ({@code gudusoft.gsqlparser.lineage.v2.producer}). An observe-only recorder never changes the
         * legacy output; a producer-mode recorder ({@code new SqllrObservations(true)}) turns the run into SQL-LR
         * production and is made only by the producer.
         *
         * @since 4.2.17
         */
        public synchronized void setSqllrObservations(SqllrObservations observations) {
                modelManager.setSqllrObservations(observations);
        }

        /** The SQL-LR observation recorder bound to this analysis, or null. Internal API of the SQL-LR producer. */
        public synchronized SqllrObservations getSqllrObservations() {
                return modelManager.getSqllrObservations();
        }

        /** Whether this analysis is the SQL-LR producer's own (an observe-only recorder changes nothing). */
        private boolean sqllrProducerMode() {
                SqllrObservations observations = modelManager.getSqllrObservations();
                return observations != null && observations.isProducerMode();
        }

        List<ErrorInfo> metadataErrors = new ArrayList<>();
        
        private synchronized dataflow analyzeSqlScript() {
                init();

                try {
                        dataflow dataflow = new dataflow();
            List<CommentBindingBundle> importedCommentBundles = null;
                        
                        if (sqlInfos != null) {
                                if (option.getHandleListener() != null) {
                                        if (sqlInfos.length == 1) {
                                                int sqlLength = sqlInfos[0].getSql() != null ? sqlInfos[0].getSql().length() : 0;
                                                option.getHandleListener().startAnalyze(null, sqlLength, false);
                                        } else {
                                                option.getHandleListener().startAnalyze(null, sqlInfos.length, true);
                                        }
                                }

                                if (sqlenv == null) {
                                        if (option.getHandleListener() != null) {
                                                option.getHandleListener().startParseSQLEnv();
                                        }
                                        TSQLEnv[] sqlenvs = new SQLEnvParser(option.getDefaultServer(), option.getDefaultDatabase(),
                                                        option.getDefaultSchema())
                                                        .withIdentifierProfile(frozenIdentifierProfile)
                                                        .parseSQLEnv(option.getVendor(), sqlInfos);
                                        if (sqlenvs != null && sqlenvs.length > 0) {
                                                sqlenv = sqlenvs[0];
                                        }
                                        if (option.getHandleListener() != null) {
                                                option.getHandleListener().endParseSQLEnv();
                                        }
                                }
                                TGSqlParser sqlparser = createPrimarySqlParser(option.getVendor());
                                Map<String, Pair3<StringBuilder, AtomicInteger, String>> databaseMap = new LinkedHashMap<String, Pair3<StringBuilder, AtomicInteger, String>>();
                                groupNameForms.clear();
                                for (int i = 0; i < sqlInfos.length; i++) {
                                        SqlInfo sqlInfo = sqlInfos[i];
                                        if (sqlInfo == null) {
                                                sqlInfoMap.put(String.valueOf(i), new ArrayList<SqlInfo>());
                                                continue;
                                        }
                                        String sql = sqlInfo.getSql();
                                        if (SQLUtil.isEmpty(sql) && sqlInfo.getFileName() != null
                                                        && new File(sqlInfo.getFileName()).exists()) {
                                                sql = SQLUtil.getFileContent(sqlInfo.getFileName());
                                        }
                                        if (SQLUtil.isEmpty(sql) && sqlInfo.getFilePath() != null
                                                        && new File(sqlInfo.getFilePath()).exists()) {
                                                sql = SQLUtil.getFileContent(sqlInfo.getFilePath());
                                        }
                                        String sqlTrim = null;
                                        if (sql != null) {
                                                sqlTrim = sql.substring(0, Math.min(sql.length(), 512)).trim();
                                        }
                                        if(sql!=null && sqlTrim.startsWith("<") && sqlTrim.indexOf("<dlineage")!=-1){
                                                dataflow temp = XML2Model.loadXML(dataflow.class, sql);
                        if (commentBindingCollector != null && temp.getCommentBindings() == null) commentBindingCollector.sourceUnavailable();
                                                if(sqlInfos.length == 1){
                                                        dataflow = temp;
                                                }
                                                else {
                            if (temp.getCommentBindings() != null) {
                                if (importedCommentBundles == null) importedCommentBundles = new ArrayList<CommentBindingBundle>();
                                // This legacy append does not offset input IDs. Keep source facts without guessing targets.
                                importedCommentBundles.add(CommentBindingProjection.sourceOnly(temp.getCommentBindings()));
                            }
                                                        if (temp.getTables() != null) {
                                                                dataflow.getTables().addAll(temp.getTables());
                                                        }
                                                        if (temp.getViews() != null) {
                                                                dataflow.getViews().addAll(temp.getViews());
                                                        }
                                                        if (temp.getResultsets() != null) {
                                                                dataflow.getResultsets().addAll(temp.getResultsets());
                                                        }
                                                        if (temp.getRelationships() != null) {
                                                                dataflow.getRelationships().addAll(temp.getRelationships());
                                                        }
                                                        if (temp.getErrors() != null) {
                                                                dataflow.getErrors().addAll(temp.getErrors());
                                                        }
                                                }
                                        }
                                        else if (sql != null && sqlTrim.startsWith("{")) {
                                                EDbVendor vendor = SQLUtil.isEmpty(sqlInfo.getDbVendor()) ? option.getVendor()
                                                                : EDbVendor.valueOf(sqlInfo.getDbVendor());
                                                // Pass the manifest's directory so a sharded manifest supplied
                                                // as inline content can still resolve its relative catalog
                                                // paths (otherwise baseDir is null and the catalog is not read).
                                                String envBaseDir = sqlInfo.getFilePath() != null
                                                                ? new File(sqlInfo.getFilePath()).getParent() : null;
                                                TSQLEnv[] sqlenvs = new TJSONSQLEnvParser(option.getDefaultServer(),
                                                                option.getDefaultDatabase(), option.getDefaultSchema())
                                                                .withIdentifierProfile(frozenIdentifierProfile)
                                                                .parseSQLEnv(vendor, sql, envBaseDir);
                                                if (sqlenvs != null && sqlenvs.length > 0) {
                                                        if (sqlenv == null) {
                                                                sqlenv = sqlenvs[0];
                                                        } else {
                                                                sqlenv = SQLEnvParser.mergeSQLEnv(Arrays.asList(sqlenv, sqlenvs[0]));
                                                        }
                                                }
                                                if (sqlenv != null) {
                                                        if (MetadataReader.isGrabit(sql) || MetadataReader.isSqlflow(sql) || MetadataReader.isSqlflowSharded(sql)) {
                                                                String hash = SHA256.getMd5(sql);
                                                                String fileHash = SHA256.getMd5(hash);
                                                                if (!sqlInfoMap.containsKey(fileHash)) {
                                                                        sqlInfoMap.put(fileHash, new ArrayList<SqlInfo>());
                                                                        sqlInfoMap.get(fileHash).add(sqlInfo);
                                                                }
                                                                ModelBindingManager.setGlobalHash(fileHash);
                                                                dataflow temp = null;

                                                                // Check the authoritative sharded `format` before the
                                                                // grabit brand: a grabit-branded sharded manifest must go
                                                                // to the sharded reader, not GrabitMetadataAnalyzer.
                                                                if (MetadataReader.isSqlflowSharded(sql)) {
                                                                        String baseDir = null;
                                                                        if (sqlInfo.getFilePath() != null) {
                                                                                baseDir = new File(sqlInfo.getFilePath()).getParent();
                                                                        }
                                                                        temp = new SqlflowShardedMetadataAnalyzer(baseDir).analyzeMetadata(option.getVendor(), sql);
                                                                } else if (MetadataReader.isGrabit(sql)) {
                                                                        temp = new GrabitMetadataAnalyzer().analyzeMetadata(option.getVendor(), sql);
                                                                } else {
                                                                        temp = new SqlflowMetadataAnalyzer(sqlenv).analyzeMetadata(option.getVendor(), sql);
                                                                }
//                                                              if (temp.getPackages() != null) {
//                                                                      dataflow.getPackages().addAll(temp.getPackages());
//                                                              }
//                                                              if (temp.getProcedures() != null) {
//                                                                      dataflow.getProcedures().addAll(temp.getProcedures());
//                                                              }
                                                                if (temp.getTables() != null) {
                                                                        dataflow.getTables().addAll(temp.getTables());
                                                                }
                                                                if (temp.getViews() != null) {
                                                                        dataflow.getViews().addAll(temp.getViews());
                                                                }
                                                                if (temp.getResultsets() != null) {
                                                                        dataflow.getResultsets().addAll(temp.getResultsets());
                                                                }
                                                                if (temp.getRelationships() != null) {
                                                                        dataflow.getRelationships().addAll(temp.getRelationships());
                                                                }
                                                                if (temp.getErrors() != null) {
                                                                        dataflow.getErrors().addAll(temp.getErrors());
                                                                }
                                                                if (sql.indexOf("createdBy") != -1) {
                                                                        // Route on the authoritative `format` field, not the
                                                                        // `createdBy` product brand. A sqlflow-sharded manifest
                                                                        // carries the exporter brand (SQLdep/sqlflow/grabit) in
                                                                        // createdBy; a plain substring check on the brand hijacked
                                                                        // SQLdep-branded sharded exports into the single-file
                                                                        // `queries` path, which finds no `queries` array and read
                                                                        // nothing. Exclude sharded manifests from the brand branch
                                                                        // so they fall through to the sharded reader below.
                                                                        if ((sql.toLowerCase(Locale.ROOT).indexOf("sqldep") != -1
                                                                                        || sql.toLowerCase(Locale.ROOT).indexOf("grabit") != -1)
                                                                                        && !MetadataReader.isSqlflowSharded(sql)) {
                                                                                Map jsonObject = (Map) JSON.parseObject(sql);
                                                                                List<Map> queries = (List<Map>) jsonObject.get("queries");
                                                                                if (queries != null) {
                                                                                        for (int j = 0; j < queries.size(); j++) {
                                                                                                Map queryObject = queries.get(j);
                                                                                                // SQLDep and Grabit inputs refuse CATALOG_STORED.
                                                                                                appendSqlInfo(databaseMap, j, sqlInfo, queryObject,
                                                                                                                IdentifierInputForm.SQL_LEXICAL);
                                                                                        }
                                                                                }
                                                                        } else if (sql.toLowerCase(Locale.ROOT).indexOf("sqlflow") != -1) {
                                                                                Map sqlflow = (Map) JSON.parseObject(sql);
                                                                                if ("sqlflow-sharded".equals(sqlflow.get("format"))
                                                                                                && !MetadataReader.isSupportedSqlflowSharded(sql)) {
                                                                                        ErrorInfo errorInfo = new ErrorInfo();
                                                                                        errorInfo.setErrorType(ErrorInfo.METADATA_ERROR);
                                                                                        errorInfo.setErrorMessage("Unsupported sqlflow-sharded formatVersion "
                                                                                                        + MetadataReader.shardedFormatVersion(sql)
                                                                                                        + "; this build supports up to "
                                                                                                        + MetadataReader.SUPPORTED_SHARDED_FORMAT_VERSION
                                                                                                        + ". Source SQL not loaded.");
                                                                                        errorInfo.setFileName(sqlInfo.getFileName());
                                                                                        errorInfo.setFilePath(sqlInfo.getFilePath());
                                                                                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(-1L, -1L,
                                                                                                        ModelBindingManager.getGlobalHash()));
                                                                                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(-1L, -1L,
                                                                                                        ModelBindingManager.getGlobalHash()));
                                                                                        errorInfo.setOriginStartPosition(new Pair<Long, Long>(-1L, -1L));
                                                                                        errorInfo.setOriginEndPosition(new Pair<Long, Long>(-1L, -1L));
                                                                                        metadataErrors.add(errorInfo);
                                                                                } else if ("sqlflow-sharded".equals(sqlflow.get("format"))) {
                                                                                        String baseDir = null;
                                                                                        if (sqlInfo.getFilePath() != null) {
                                                                                                baseDir = new File(sqlInfo.getFilePath()).getParent();
                                                                                        }
                                                                                        String sourceCompression = (String) sqlflow.get("sourceCompression");
                                                                                        List<Map> servers = (List<Map>) sqlflow.get("servers");
                                                                                        if (servers != null) {
                                                                                                for (Map serverObject : servers) {
                                                                                                        List<Map> databases = (List<Map>) serverObject.get("databases");
                                                                                                        // Source shards live under databases[] (catalog topology) or
                                                                                                        // schemas[] (schema topology, the natural Oracle shape). Both
                                                                                                        // carry a per-shard `source`; iterate whichever is present.
                                                                                                        // Reading only databases[] silently dropped every source record
                                                                                                        // of a schema-topology manifest -> empty lineage.
                                                                                                        List<Map> schemaShards = (List<Map>) serverObject.get("schemas");
                                                                                                        if (schemaShards != null && !schemaShards.isEmpty()) {
                                                                                                                databases = schemaShards;
                                                                                                        }
                                                                                                        if (databases != null) {
                                                                                                                for (Map database : databases) {
                                                                                                                        Map source = (Map) database.get("source");
                                                                                                                        if (source != null) {
                                                                                                                                String sourcePath = (String) source.get("path");
                                                                                                                                if (sourcePath != null && baseDir != null) {
                                                                    File sourceFile = new File(baseDir, sourcePath);
                                                                                                                                        String fullPath = sourceFile.getAbsolutePath();
                                                                                                                                        if ("block".equals(sourceCompression)) {
                                                                                                                                                readGzipBlockSource(fullPath, databaseMap, sqlInfo,
                                                                                                                                                                SqlflowNameForm.declared(sqlflow));
                                                                                                                                        } else {
                                                                                                                                                String sourceContent = SQLUtil.getFileContent(fullPath);
                                                                                                                                                if (sourceContent != null) {
                                                                                                                                                        String[] lines = sourceContent.split("\\r?\\n");
                                                                                                                                                        for (int j = 0; j < lines.length; j++) {
                                                                                                                                                                String line = lines[j].trim();
                                                                                                                                                                if (line.isEmpty()) {
                                                                                                                                                                        continue;
                                                                                                                                                                }
                                                                                                                                                                try {
                                                                                                                                                                        Map sourceObject = (Map) JSON.parseObject(line);
                                                                                                                                                                        String sourceCode = (String) sourceObject.get("sourceCode");
                                                                                                                                                                        if (sourceCode != null && !sourceCode.isEmpty()) {
                                                                                                                                                                                SqlInfo sourceSqlInfo = new SqlInfo();
                                                                                                                                                                                sourceSqlInfo.setFileName(sourceFile.getName());
                                                                                                                                                                                sourceSqlInfo.setFilePath(sourceFile.getAbsolutePath());
                                                                                                                                                                                sourceSqlInfo.setSql(sourceCode);
                                                                                                                                                                                sourceSqlInfo.setOriginIndex(j);
                                                                                                                                                                                appendSqlInfo(databaseMap, j, sourceSqlInfo, sourceObject,
                                                                                                                                                                                                SqlflowNameForm.declared(sqlflow));
                                                                                                                                                                        }
                                                                                                                                                                } catch (Exception e) {
                                                                                                                                                                        logger.warn("Parse source jsonl line failed.", e);
                                                                                                                                                                }
                                                                                                                                                        }
                                                                                                                                                }
                                                                                                                                        }
                                                                                                                                }
                                                                                                                        }
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                } else {
                                                                                        List<Map> servers = (List<Map>) sqlflow.get("servers");
                                                                                        if (servers != null) {
                                                                                                for (Map serverObject : servers) {
                                                                                                        List<Map> queries = (List<Map>) serverObject.get("queries");
                                                                                                        if (queries != null) {
                                                                                                                IdentifierInputForm nameForm = SqlflowNameForm.declared(sqlflow);
                                                                                                                for (int j = 0; j < queries.size(); j++) {
                                                                                                                        Map queryObject = queries.get(j);
                                                                                                                        appendSqlInfo(databaseMap, j, sqlInfo, queryObject, nameForm);
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                }
                                                                                List<Map> errorMessages =  (List<Map>) sqlflow.get("errorMessages");
                                                                                if(errorMessages!=null && !errorMessages.isEmpty()) {
                                                                                        for(Map error: errorMessages){
                                                                                                ErrorInfo errorInfo = new ErrorInfo();
                                                                                                errorInfo.setErrorType(ErrorInfo.METADATA_ERROR);
                                                                                                errorInfo.setErrorMessage((String)error.get("errorMessage"));
                                                                                                errorInfo.setFileName(sqlInfo.getFileName());
                                                                                                errorInfo.setFilePath(sqlInfo.getFilePath());
                                                                                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(-1L, -1L,
                                                                                                                ModelBindingManager.getGlobalHash()));
                                                                                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(-1L, -1L,
                                                                                                                ModelBindingManager.getGlobalHash()));
                                                                                                errorInfo.setOriginStartPosition(new Pair<Long, Long>(-1L, -1L));
                                                                                                errorInfo.setOriginEndPosition(new Pair<Long, Long>(-1L, -1L));
                                                                                                metadataErrors.add(errorInfo);
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        } else {
                                                                Map queryObject = (Map) JSON.parseObject(sql);
                                                                appendSqlInfo(databaseMap, i, sqlInfo, queryObject);
                                                        }
                                                } else {
                                                        Map queryObject = (Map) JSON.parseObject(sql);
                                                        appendSqlInfo(databaseMap, i, sqlInfo, queryObject);
                                                }
                                        } else {
                                                ModelBindingManager.removeGlobalDatabase();
                                                ModelBindingManager.removeGlobalSchema();
                                                ModelBindingManager.removeGlobalHash();

                                                String content = sql;

                                                if (content == null) {
                                                        continue;
                                                }

                                                String delimiterChar = String.valueOf(sqlparser.getDelimiterChar());

                                                // SQL-LR production parses every input as its own unit, from its text unchanged: positions are
                                                // published against that text, and no other input is appended to it.
                                                if (sqlInfos.length > 1 && !sqllrProducerMode()) {
                                                        String endTrim = SQLUtil.endTrim(content);
                                                        if (endTrim.endsWith(delimiterChar) || endTrim.endsWith(";")) {
                                                                content += "\n";
                                                        } else if (option.getVendor() == EDbVendor.dbvredshift
                                                                        || option.getVendor() == EDbVendor.dbvgaussdb
                                                                        || option.getVendor() == EDbVendor.dbvedb
                                                                        || option.getVendor() == EDbVendor.dbvpostgresql
                                                                        || option.getVendor() == EDbVendor.dbvmysql
                                                                        || option.getVendor() == EDbVendor.dbvteradata) {
                                                                content += ("\n\n-- " + TBaseType.sqlflow_stmt_delimiter_str + "\n\n");
                                                        } else {
                                                                content = endTrim + ";" + "\n";
                                                        }
                                                }

                                                sqlInfo.setSql(content);

                                                if (MetadataReader.isMetadata(content)) {
                                                        String hash = SHA256.getMd5(content);
                                                        ModelBindingManager.setGlobalHash(hash);
                                                        dataflow temp = new SQLDepMetadataAnalyzer().analyzeMetadata(option.getVendor(), content);
                                                        if (temp.getProcedures() != null) {
                                                                dataflow.getProcedures().addAll(temp.getProcedures());
                                                        }
                                                        if (temp.getTables() != null) {
                                                                dataflow.getTables().addAll(temp.getTables());
                                                        }
                                                        if (temp.getViews() != null) {
                                                                dataflow.getViews().addAll(temp.getViews());
                                                        }
                                                        if (temp.getResultsets() != null) {
                                                                dataflow.getResultsets().addAll(temp.getResultsets());
                                                        }
                                                        if (temp.getRelationships() != null) {
                                                                dataflow.getRelationships().addAll(temp.getRelationships());
                                                        }
                                                        if (temp.getErrors() != null) {
                                                                dataflow.getErrors().addAll(temp.getErrors());
                                                        }
                                                        String fileHash = SHA256.getMd5(hash);
                                                        if (!sqlInfoMap.containsKey(fileHash)) {
                                                                sqlInfoMap.put(fileHash, new ArrayList<SqlInfo>());
                                                                sqlInfoMap.get(fileHash).add(sqlInfo);
                                                        }
                                                } else {
                                                        // SQL-LR production keys each input as its own unit: two files with equal text are
                                                        // two source units (specification Section 7.8), never one unit holding the text twice.
                                                        String sqlHash = sqllrProducerMode()
                                                                        ? SHA256.getMd5(content + "\u0000sqllr-unit-" + i) : SHA256.getMd5(content);
                                                        if (modelManager.getSqllrObservations() != null) {
                                                                modelManager.getSqllrObservations().registerUnit(sqlHash, i);
                                                        }
                                                        String fileHash = SHA256.getMd5(sqlHash);
                                                        if (!sqlInfoMap.containsKey(fileHash)) {
                                                                sqlInfoMap.put(fileHash, new ArrayList<SqlInfo>());
                                                        }

                                                        String database = TSQLEnv.DEFAULT_DB_NAME;
                                                        String schema = TSQLEnv.DEFAULT_SCHEMA_NAME;
                                                        if (sqlenv != null) {
                                                                // Prefer the per-analysis Option default database over the attached
                                                                // env's default catalog, so a shared multi-catalog TSQLEnv can be
                                                                // reused across analyses with different default databases without
                                                                // the env's default catalog deciding name resolution.
                                                                if (!SQLUtil.isEmpty(option.getDefaultDatabase())
                                                                                && !TSQLEnv.DEFAULT_DB_NAME.equals(option.getDefaultDatabase())) {
                                                                        database = option.getDefaultDatabase();
                                                                } else {
                                                                        database = sqlenv.getDefaultCatalogName();
                                                                }
                                                                if (database == null) {
                                                                        database = TSQLEnv.DEFAULT_DB_NAME;
                                                                }
                                                                schema = sqlenv.getDefaultSchemaName();
                                                                if (schema == null) {
                                                                        schema = TSQLEnv.DEFAULT_SCHEMA_NAME;
                                                                }
                                                        }

                                                        boolean supportCatalog = TSQLEnv.supportCatalog(option.getVendor());
                                                        boolean supportSchema = TSQLEnv.supportSchema(option.getVendor());
                                                        String group;
                                                        IdentifierInputForm groupForm = null;
                                                        if (sqlInfo.getGroup() != null && !sqlInfo.getGroup().isEmpty()) {
                                                                group = sqlInfo.getGroup();
                                                                groupForm = sqlInfo.getGroupNameForm();
                                                        } else {
                                                                StringBuilder builder = new StringBuilder();
                                                                if (supportCatalog) {
                                                                        builder.append(database);
                                                                }
                                                                if (supportSchema) {
                                                                        if (builder.length() > 0) {
                                                                                builder.append(".");
                                                                        }
                                                                        builder.append(schema);
                                                                }
                                                                group = builder.toString();
                                                        }
                                                        SqlInfo sqlInfoItem = new SqlInfo();
                                                        sqlInfoItem.setFileName(sqlInfo.getFileName());
                                                        sqlInfoItem.setFilePath(sqlInfo.getFilePath());
                                                        sqlInfoItem.setSql(sqlInfo.getSql());
                                                        sqlInfoItem.setOriginIndex(0);
                                                        sqlInfoItem.setOriginLineStart(0);
                                                        int lineEnd = sqlInfo.getSql().split("\n").length - 1;
                                                        sqlInfoItem.setOriginLineEnd(lineEnd);
                                                        sqlInfoItem.setIndex(0);
                                                        sqlInfoItem.setLineStart(0);
                                                        sqlInfoItem.setLineEnd(lineEnd);
                                                        sqlInfoItem.setHash(SHA256.getMd5(sqlHash));
                                                        sqlInfoItem.setGroup(group);
                                                        sqlInfoMap.get(fileHash).add(sqlInfoItem);
                                                        if (!databaseMap.containsKey(sqlHash)) {
                                                                databaseMap.put(sqlHash, new Pair3<StringBuilder, AtomicInteger, String>(
                                                                                new StringBuilder(), new AtomicInteger(), group));
                                                                if (groupForm == IdentifierInputForm.CATALOG_STORED) {
                                                                        groupNameForms.put(sqlHash, groupForm);
                                                                }
                                                        }
                                                        if (commentBindingCollector != null) commentBindingCollector.register(sqlHash, sqlInfoItem.getSql(),
                                databaseMap.get(sqlHash).first.length(), i, sqlInfoItem.getFileName(), "derived".equals(sqlInfo.getSourceOriginKind()));
                            databaseMap.get(sqlHash).first.append(sqlInfoItem.getSql());
                                                        databaseMap.get(sqlHash).second.incrementAndGet();
                                                }
                                        }
                                }

                                boolean supportCatalog = TSQLEnv.supportCatalog(option.getVendor());
                                boolean supportSchema = TSQLEnv.supportSchema(option.getVendor());

                                // Cross-file call-site binding discovery (plan Phase 5) needs every
                                // unit's text before the first unit is analyzed: units are parsed and
                                // analyzed strictly one at a time, so a caller in a later file would
                                // otherwise be invisible while an earlier file's procedure is analyzed.
                                if ((option.getVendor() == EDbVendor.dbvmssql || option.getVendor() == EDbVendor.dbvoracle)
                                                && databaseMap.size() > 1) {
                                        List<String> unitTexts = new ArrayList<String>();
                                        for (Pair3<StringBuilder, AtomicInteger, String> unit : databaseMap.values()) {
                                                unitTexts.add(unit.first.toString());
                                        }
                                        routineCatalog = new gudusoft.gsqlparser.dlineage.dynamicsql.RoutineCatalog(
                                                        option.getVendor(), unitTexts, crossFileParseCache);
                                }

                                // Two different names that share one legacy normal name must be told apart from the
                                // first unit on, so every unit is scanned before any is analyzed: a lone unit from the
                                // tokens its parse reads anyway, several by lexing their text first. Names are told
                                // apart under the analysis's own rules, a configured profile's included.
                                collisionScanPending = false;
                                if (databaseMap.size() == 1) {
                                        collisionScanPending = true;
                                } else {
                                        List<String> unitTexts = new ArrayList<String>();
                                        for (Pair3<StringBuilder, AtomicInteger, String> unit : databaseMap.values()) {
                                                unitTexts.add(unit.first.toString());
                                        }
                                        publishContestedNormalNames(NormalNameCollisions.scan(collisionService(), unitTexts));
                                }

                                Iterator<String> schemaIter = databaseMap.keySet().iterator();
                                while (schemaIter.hasNext()) {
                                        if (option.getHandleListener() != null && option.getHandleListener().isCanceled()) {
                                                break;
                                        }
                                        String key = schemaIter.next();
                                        String group = databaseMap.get(key).third;
                                        String[] split = SQLUtil.parseNames(group).toArray(new String[0]);

                                        ModelBindingManager.removeGlobalDatabase();
                                        ModelBindingManager.removeGlobalSchema();
                                        ModelBindingManager.removeGlobalSQLEnv();
                                        ModelBindingManager.removeGlobalHash();

                                        if (sqlenv == null) {
                                                // The placeholder carries the analysis's own profile: built on the vendor
                                                // default, it contradicts a configured profile and the parser refuses the pair.
                                                sqlenv = new TSQLEnv(option.getVendor(),
                                                                IdentifierProfile.forVendorOr(frozenIdentifierProfile, option.getVendor())) {

                                                        @Override
                                                        public void initSQLEnv() {
                                                        }
                                                };
                                        }
                                        
                                        String defaultDatabase = null;
                                        String defaultSchema = null;
                                        if(sqlenv!=null){
                                                defaultDatabase = sqlenv.getDefaultCatalogName();
                                                defaultSchema = sqlenv.getDefaultSchemaName();
                                        }
                                        IdentifierInputForm groupForm = groupNameForms.get(key);
                                        if (supportCatalog && supportSchema) {
                                                if (split.length >= 2) {
                                                        if (!TSQLEnv.DEFAULT_DB_NAME.equals(split[split.length - 2])) {
                                                                ModelBindingManager.setGlobalDatabase(split[split.length - 2], groupForm);
                                                                sqlenv.setDefaultCatalogName(ModelBindingManager.getGlobalDatabase());
                                                        }
                                                }
                                                if (split.length >= 1) {
                                                        if (!TSQLEnv.DEFAULT_SCHEMA_NAME.equals(split[split.length - 1])) {
                                                                ModelBindingManager.setGlobalSchema(split[split.length - 1], groupForm);
                                                                sqlenv.setDefaultSchemaName(ModelBindingManager.getGlobalSchema());
                                                        }
                                                }
                                        } else if (supportCatalog) {
                                                if (!TSQLEnv.DEFAULT_DB_NAME.equals(split[split.length - 1])) {
                                                        ModelBindingManager.setGlobalDatabase(split[split.length - 1], groupForm);
                                                        sqlenv.setDefaultCatalogName(ModelBindingManager.getGlobalDatabase());
                                                }
                                        } else if (supportSchema) {
                                                if (!TSQLEnv.DEFAULT_SCHEMA_NAME.equals(split[split.length - 1])) {
                                                        ModelBindingManager.setGlobalSchema(split[split.length - 1], groupForm);
                                                        sqlenv.setDefaultSchemaName(ModelBindingManager.getGlobalSchema());
                                                }
                                        }
                                        if (option.getHandleListener() != null) {
                                                option.getHandleListener().startParse(null, databaseMap.get(key).first.toString());
                                        }

                                        ModelBindingManager.setGlobalSQLEnv(sqlenv);
                                        sqlparser.sqltext = databaseMap.get(key).first.toString();
                                        ModelBindingManager.setGlobalHash(SHA256.getMd5(key));
                                        commentSourceKey = key;
                                        if (modelManager.getSqllrObservations() != null) {
                                                modelManager.getSqllrObservations().beginUnit(key);
                                        }
                    analyzeAndOutputResult(sqlparser);
                                        if(sqlenv!=null){
                                                sqlenv.setDefaultCatalogName(defaultDatabase);
                                                sqlenv.setDefaultSchemaName(defaultSchema);
                                        }
                                        // An EXEC of a routine that this unit defines binds its arguments now, before a later unit
                                        // changes what the call's arguments resolve to.
                                        bindDeferredExecuteArguments();
                                }
                                // A call whose routine no unit defines stays unbound.
                                deferredExecuteBindings.clear();

                                materializeSqlEnvSynonyms();

                                if (modelManager.getSqllrObservations() != null) {
                                        // the SQL-LR producer reads the graph as analysis left it; appendRelation below changes it
                                        modelManager.getSqllrObservations().freeze(modelManager);
                                }

                                appendProcesses(dataflow);
                                appendOraclePackages(dataflow);
                                appendProcedures(dataflow);
                                appendTables(dataflow);
                                appendViews(dataflow);
                                appendResultSets(dataflow);
                                appendRelations(dataflow);
                                appendErrors(dataflow);
                        }

            if (importedCommentBundles != null) dataflow.setCommentBindings(CommentBindingProjection.merge(importedCommentBundles));
                        if (commentBindingCollector != null && dataflow != null) {
                CommentBindingBundle collected = commentBindingCollector.build(modelManager);
                if (dataflow.getCommentBindings() == null) dataflow.setCommentBindings(collected);
                else if (!collected.getSourceUnits().isEmpty() || !"complete".equals(collected.getState())) dataflow.setCommentBindings(CommentBindingProjection.merge(
                        Arrays.asList(dataflow.getCommentBindings(), collected)));
                CommentBindingProjection.retain(dataflow, false);
            }
            dataflow = handleDataflowExecProcedure(dataflow);

                        if (dataflow != null && option.getAnalyzeMode() != AnalyzeMode.crud) {
                                if (!isShowJoin()) {
                                        dataflow = mergeTables(dataflow, modelManager.TABLE_COLUMN_ID, option);
                                } else {
                                        dataflow = removeDuplicateColumns(dataflow);
                                }
                        }

                        if (dataflow != null && option.isNormalizeOutput()) {
                                dataflow = getNormalizeDataflow(dataflow);
                        }

                        if (dataflow != null && option.isIgnoreCoordinate()) {
                                dataflow = filterDataflowCoordinate(dataflow);
                        }

                        // once the names and coordinates are final: blanked coordinates can make two relationships one
                        if (dataflow != null && option.getAnalyzeMode() != AnalyzeMode.crud && !endpointLabelsDeferred) {
                                DataflowUtility.labelEndpoints(dataflow);
                        }
                        
                        if (option.isSimpleOutput() || option.isIgnoreRecordSet()) {
                                List<String> showTypes = new ArrayList<>();
                                if(option.getSimpleShowRelationTypes()!=null) {
                                        showTypes.addAll(option.getSimpleShowRelationTypes());
                                }
                                if(showTypes.isEmpty()) {
                                        showTypes.add("fdd");
                                }
                                if(option.isShowCallRelation()) {
                                        showTypes.add("call");
                                }
                                if(option.isShowERDiagram()) {
                                        showTypes.add("er");
                                }
                                dataflow simpleDataflow = getSimpleDataflow(dataflow, option.isSimpleOutput(), showTypes);
                                if (simpleDataflow.getResultsets() != null) {
                                        for (table t : simpleDataflow.getResultsets()) {
                                                t.setIsTarget(null);
                                        }
                                }
                                return finalizeAuthoritativeLineageEvidence(simpleDataflow);
                        } else {
                                return finalizeAuthoritativeLineageEvidence(dataflow);
                        }
                        
                } catch (Exception e) {
                        logger.error("analyze sql failed.", e);
                        ErrorInfo errorInfo = new ErrorInfo();
                        errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                        if (e.getMessage() == null) {
                                if (e.getStackTrace() != null && e.getStackTrace().length > 0) {
                                        errorInfo.setErrorMessage(e.getClass().getSimpleName() + ": " + e.getStackTrace()[0].toString());
                                } else {
                                        errorInfo.setErrorMessage(e.getClass().getSimpleName());
                                }
                        } else {
                                errorInfo.setErrorMessage(e.getClass().getSimpleName() + ": " + e.getMessage());
                        }
                        errorInfo.fillInfo(this);
                        errorInfos.add(errorInfo);
                }

                modelManager.reset();
                return null;
        }

        private dataflow finalizeAuthoritativeLineageEvidence(dataflow completed) {
                if (!shouldCollectAuthoritativeLineageEvidence()) {
                        authoritativeEvidenceCollector.reset();
                        authoritativeLineageEvidence = AuthoritativeLineageEvidence.empty();
                        return completed;
                }
                try {
                        authoritativeLineageEvidence = authoritativeEvidenceCollector.build(modelManager, completed);
                } catch (ThreadDeath fatal) {
                        throw fatal;
                } catch (VirtualMachineError fatal) {
                        throw fatal;
                } catch (Throwable evidenceFailure) {
                        // Additive evidence must never make the established legacy analyzer fail.
                        logger.error("Capture authoritative lineage evidence failed; legacy output is preserved.",
                                        evidenceFailure);
                        authoritativeLineageEvidence = AuthoritativeLineageEvidence.empty();
                } finally {
                        // Drafts retain AST/model objects. The published bundle contains only
                        // immutable scalar values, so release all per-run references immediately.
                        authoritativeEvidenceCollector.reset();
                }
                return completed;
        }

        private boolean shouldCollectAuthoritativeLineageEvidence() {
                return option != null && option.isCollectAuthoritativeLineageEvidence();
        }

        private dataflow handleDataflowExecProcedure(dataflow dataflow) {
                // The xml objects' models, reached by id: the join compares the routines' names as written.
                Map<String, Procedure> procedureModels = new HashMap<String, Procedure>();
                for (Procedure model : modelManager.getProcedureModels()) {
                        procedureModels.put(String.valueOf(model.getId()), model);
                }
                Set<RoutineAliasKey> procedureKeys = new HashSet<RoutineAliasKey>();
                for (procedure procedure : dataflow.getProcedures()) {
                        Procedure model = procedureModels.get(procedure.getId());
                        if (model != null && model.getAliasKey() != null) {
                                procedureKeys.add(model.getAliasKey());
                        }
                }
                Map<String, ResultSet> resultSetModels = new HashMap<String, ResultSet>();
                for (ResultSet model : modelManager.getResultSets()) {
                        resultSetModels.put(String.valueOf(model.getId()), model);
                }
                List<table> removeResultSets = new ArrayList<table>();
                
                Map<String, table> allMap = new HashMap<String, table>();
                Map<String, column> columnsById = DlineageUtil.outputColumnsById(dataflow);
                
                if (dataflow.getResultsets() != null) {
                        for (table t : dataflow.getResultsets()) {
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (dataflow.getTables() != null) {
                        for (table t : dataflow.getTables()) {
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (dataflow.getViews() != null) {
                        for (table t : dataflow.getViews()) {
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (dataflow.getVariables() != null) {
                        for (table t : dataflow.getVariables()) {
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                
                for (table resultSet : dataflow.getResultsets()) {
                        boolean functionResult = ResultSetType.function.name().equals(resultSet.getType());
                        RoutineAliasKey resultSetKey = functionResult ? resultSetAliasKey(resultSetModels.get(resultSet.getId())) : null;
                        boolean join = resultSetKey != null && modelManager.getFunctionResults(resultSetKey) != null
                                        && procedureKeys.contains(resultSetKey);
                        if (!join) {
                                continue;
                        }

                        Set<Object> functionTables = modelManager.getFunctionResults(resultSetKey);
                        List<ResultSet> functionResults = functionTables.stream().filter(t -> t instanceof ResultSet)
                                        .map(t -> (ResultSet) t).collect(Collectors.toList());
                        if (!(resultSet.getColumns().size() == 1
                                        && DlineageUtil.sameQualifiedName(ESQLDataObjectType.dotTable, resultSet.getColumns().get(0).getName(), resultSet.getName()))
                                        || functionResults.isEmpty()) {
                                continue;
                        }

                        column column = resultSet.getColumns().get(0);
                        String sourceColumnId = column.getId();
                        boolean reserveResultSet = false;
                        List<relationship> appendRelations = new ArrayList<relationship>();
                        Set<relationship> removeRelations = new HashSet<relationship>();
                        
                        for (relationship relationship : dataflow.getRelationships()) {
                                targetColumn targetColumn = relationship.getTarget();
                                List<sourceColumn> sourceColumns = relationship.getSources();
                                List<sourceColumn> newSourceColumns = new ArrayList<sourceColumn>();
                                for (sourceColumn sourceColumn : sourceColumns) {
                                        if (!sourceColumn.getId().equals(sourceColumnId)) {
                                                continue;
                                        }
                                        for (ResultSet sourceResultSet : functionResults) {
                                                for (ResultColumn resultColumn : sourceResultSet.getColumns()) {
                                                        if (!DlineageUtil.compareColumnIdentifier(resultColumn.getName(),
                                                                        targetColumn.getColumn())) {
                                                                if (DlineageUtil.isStarEndpoint(columnsById, targetColumn.getId(), targetColumn.getColumn())) {
                                                                        table parent = allMap.get(targetColumn.getParent_id());
                                                                        if (parent != null && parent.getColumns().size() > 1) {
                                                                                for (column item : parent.getColumns()) {
                                                                                        if (DlineageUtil.compareColumnIdentifier(resultColumn.getName(),
                                                                                                        item.getName())) {
                                                                                                relationship newRelation = appendStarRelation(dataflow, relationship, item, resultColumn);
                                                                                                appendRelations.add(newRelation);
                                                                                                removeRelations.add(relationship);
                                                                                                newSourceColumns.add(newRelation.getSources().get(0));
                                                                                                if (resultColumn.getResultSet() != null && resultColumn.getResultSet().isTarget()) {
                                                                                                        dataflow.getResultsets().stream().filter(
                                                                                                                        t -> t.getId().equals(String.valueOf(resultColumn.getResultSet().getId())))
                                                                                                                        .forEach(t -> t.setIsTarget(Boolean.FALSE.toString()));
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                                continue;
                                                        }
                                                        
                                                        sourceColumn sourceColumn1 = new sourceColumn();
                                                        sourceColumn1.setId(String.valueOf(resultColumn.getId()));
                                                        sourceColumn1.setColumn(resultColumn.getName());
                                                        sourceColumn1.setParent_id(String.valueOf(resultColumn.getResultSet().getId()));
                                                        sourceColumn1.setParent_name(getResultSetName(resultColumn.getResultSet()));
                                                        if (resultColumn.getStartPosition() != null
                                                                        && resultColumn.getEndPosition() != null) {
                                                                sourceColumn1.setCoordinate(convertCoordinate(resultColumn.getStartPosition())
                                                                                + "," + convertCoordinate(resultColumn.getEndPosition()));
                                                        }
                                                        newSourceColumns.add(sourceColumn1);
                                                        
                                                        if (resultColumn.getResultSet() != null && resultColumn.getResultSet().isTarget()) {
                                                                dataflow.getResultsets().stream().filter(
                                                                                t -> t.getId().equals(String.valueOf(resultColumn.getResultSet().getId())))
                                                                                .forEach(t -> t.setIsTarget(Boolean.FALSE.toString()));
                                                        }
                                                }
                                        }

                                        if (!newSourceColumns.isEmpty()) {
                                                if (removeRelations.isEmpty()) {
                                                        relationship.setSources(newSourceColumns);
                                                }
                                        }
                                        else {
                                                reserveResultSet = true;
                                        }
                                }
                        }
                        
                        dataflow.getRelationships().addAll(appendRelations);
                        dataflow.getRelationships().removeAll(removeRelations);
                        
                        if(!reserveResultSet) {
                                removeResultSets.add(resultSet);
                        }
                }
                dataflow.getResultsets().removeAll(removeResultSets);
                return dataflow;
        }

        private relationship appendStarRelation(dataflow dataflow,
                        relationship relationship, column item, ResultColumn resultColumn) {
                relationship relationElement = new relationship();
                relationElement.setType(relationship.getType());
                relationElement.setEffectType(relationship.getEffectType());
                relationElement.setSqlHash(relationship.getSqlHash());
                relationElement.setSqlComment(relationship.getSqlComment());
                relationElement.setProcedureId(relationship.getProcedureId());
                relationElement.setId(String.valueOf(++ModelBindingManager.get().RELATION_ID));
                relationElement.setProcessId(relationship.getProcessId());
                relationElement.setProcessType(relationship.getProcessType());
                
                targetColumn targetColumn1 = new targetColumn();
                targetColumn1.setId(String.valueOf(item.getId()));
                targetColumn1.setColumn(item.getName());
                targetColumn1.setParent_id(relationship.getTarget().getParent_id());
                targetColumn1.setParent_name(relationship.getTarget().getParent_name());
                targetColumn1.setParent_alias(relationship.getTarget().getParent_alias());
                if (relationship.getTarget().getCoordinate() != null) {
                        targetColumn1.setCoordinate(item.getCoordinate());
                }
                relationElement.setTarget(targetColumn1);       
                
                sourceColumn sourceColumn1 = new sourceColumn();
                sourceColumn1.setId(String.valueOf(resultColumn.getId()));
                sourceColumn1.setColumn(resultColumn.getName());
                sourceColumn1.setParent_id(String.valueOf(resultColumn.getResultSet().getId()));
                sourceColumn1.setParent_name(getResultSetName(resultColumn.getResultSet()));
                if (resultColumn.getStartPosition() != null
                                && resultColumn.getEndPosition() != null) {
                        sourceColumn1.setCoordinate(convertCoordinate(resultColumn.getStartPosition())
                                        + "," + convertCoordinate(resultColumn.getEndPosition()));
                }
                relationElement.addSource(sourceColumn1);
                return relationElement;
        }

        private dataflow getNormalizeDataflow(dataflow instance) {
                List<table> tables = new ArrayList<>();
                if (instance.getResultsets() != null) {
                        for (table t : instance.getResultsets()) {
                                tables.add(t);
                        }
                }

                if (instance.getTables() != null) {
                        for (table t : instance.getTables()) {
                                tables.add(t);
                        }
                }

                if (instance.getViews() != null) {
                        for (table t : instance.getViews()) {
                                tables.add(t);
                        }
                }

                if (instance.getPaths() != null) {
                        for (table t : instance.getPaths()) {
                                tables.add(t);
                        }
                }

                if (instance.getStages() != null) {
                        for (table t : instance.getStages()) {
                                tables.add(t);
                        }
                }

                if (instance.getSequences() != null) {
                        for (table t : instance.getSequences()) {
                                tables.add(t);
                        }
                }

                if (instance.getDatasources() != null) {
                        for (table t : instance.getDatasources()) {
                                tables.add(t);
                        }
                }

                if (instance.getDatabases() != null) {
                        for (table t : instance.getDatabases()) {
                                tables.add(t);
                        }
                }

                if (instance.getSchemas() != null) {
                        for (table t : instance.getSchemas()) {
                                tables.add(t);
                        }
                }

                if (instance.getStreams() != null) {
                        for (table t : instance.getStreams()) {
                                tables.add(t);
                        }
                }

                if (instance.getVariables() != null) {
                        for (table t : instance.getVariables()) {
                                tables.add(t);
                        }
                }

                Map<String, String> idNameMap = new HashMap();

                for(table table: tables){
                        if(table.getDatabase()!=null) {
                                table.setDatabase(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, table.getDatabase(), ESQLDataObjectType.dotCatalog));
                        }
                        if(table.getSchema()!=null) {
                                table.setSchema(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, table.getSchema(), ESQLDataObjectType.dotSchema));
                        }
                        if(table.getName()!=null) {
                                table.setName(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, table.getName(), ESQLDataObjectType.dotTable));
                                idNameMap.put(table.getId(), table.getName());
                        }
                        if(table.getColumns()!=null){
                                for(column column: table.getColumns()){
                                        column.setName(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, column.getName(), ESQLDataObjectType.dotColumn));
                                        idNameMap.put(column.getId(), column.getName());
                                }
                        }
                }
                if(instance.getPackages()!=null){
                        for(oraclePackage oraclePackage: instance.getPackages()){
                                if(oraclePackage.getDatabase()!=null) {
                                        oraclePackage.setDatabase(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, oraclePackage.getDatabase(), ESQLDataObjectType.dotCatalog));
                                }
                                if(oraclePackage.getSchema()!=null) {
                                        oraclePackage.setSchema(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, oraclePackage.getSchema(), ESQLDataObjectType.dotSchema));
                                }
                                if(oraclePackage.getName()!=null) {
                                        oraclePackage.setName(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, oraclePackage.getName(), ESQLDataObjectType.dotTable));
                                        idNameMap.put(oraclePackage.getId(), oraclePackage.getName());
                                }
                                if(oraclePackage.getArguments()!=null){
                                        for(argument argument: oraclePackage.getArguments()){
                                                argument.setName(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, argument.getName(), ESQLDataObjectType.dotColumn));
                                                idNameMap.put(argument.getId(), argument.getName());
                                        }
                                }
                                if(oraclePackage.getProcedures()!=null){
                                        for(procedure procedure: oraclePackage.getProcedures()){
                                                if(procedure.getDatabase()!=null) {
                                                        procedure.setDatabase(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, procedure.getDatabase(), ESQLDataObjectType.dotCatalog));
                                                }
                                                if(procedure.getSchema()!=null) {
                                                        procedure.setSchema(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, procedure.getSchema(), ESQLDataObjectType.dotSchema));
                                                }
                                                if(procedure.getName()!=null) {
                                                        procedure.setName(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, procedure.getName(), ESQLDataObjectType.dotTable));
                                                        idNameMap.put(procedure.getId(), procedure.getName());
                                                }
                                                for(argument argument: procedure.getArguments()){
                                                        argument.setName(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, argument.getName(), ESQLDataObjectType.dotColumn));
                                                        idNameMap.put(argument.getId(), argument.getName());
                                                }
                                        }
                                }
                        }
                }
                if(instance.getProcedures()!=null){
                        for(procedure procedure: instance.getProcedures()){
                                if(procedure.getDatabase()!=null) {
                                        procedure.setDatabase(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, procedure.getDatabase(), ESQLDataObjectType.dotCatalog));
                                }
                                if(procedure.getSchema()!=null) {
                                        procedure.setSchema(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, procedure.getSchema(), ESQLDataObjectType.dotSchema));
                                }
                                if(procedure.getName()!=null) {
                                        procedure.setName(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, procedure.getName(), ESQLDataObjectType.dotTable));
                                        idNameMap.put(procedure.getId(), procedure.getName());
                                }
                                for(argument argument: procedure.getArguments()){
                                        argument.setName(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, argument.getName(), ESQLDataObjectType.dotColumn));
                                        idNameMap.put(argument.getId(), argument.getName());
                                }
                        }
                }
                if (instance.getProcesses() != null) {
                        for (process process : instance.getProcesses()) {
                                if(process.getDatabase()!=null) {
                                        process.setDatabase(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, process.getDatabase(), ESQLDataObjectType.dotCatalog));
                                }
                                if(process.getSchema()!=null) {
                                        process.setSchema(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, process.getSchema(), ESQLDataObjectType.dotSchema));
                                }
                                if (process.getProcedureId() != null) {
                                        process.setProcedureName(LegacyDlineageWireNamesV1.name(LegacyDlineageWireNamesV1.Profile.NORMALIZED_OUTPUT, process.getProcedureName(), ESQLDataObjectType.dotTable));
                                        idNameMap.put(process.getId(), process.getName());
                                }
                        }
                }

                if(instance.getRelationships()!=null){
                        for(relationship relation: instance.getRelationships()){
                                targetColumn targetColumn = relation.getTarget();
                                if(targetColumn != null) {
                                        targetColumn.setColumn(idNameMap.get(targetColumn.getId()));
                                        targetColumn.setTarget_name(idNameMap.get(targetColumn.getTarget_id()));
                                        targetColumn.setParent_name(idNameMap.get(targetColumn.getParent_id()));
                                }
                                List<sourceColumn> sourceColumns = relation.getSources();
                                if(sourceColumns!=null){
                                        for(sourceColumn sourceColumn: sourceColumns){
                                                sourceColumn.setColumn(idNameMap.get(sourceColumn.getId()));
                                                sourceColumn.setSource_name(idNameMap.get(sourceColumn.getSource_id()));
                                                sourceColumn.setParent_name(idNameMap.get(sourceColumn.getParent_id()));
                                        }
                                }
                                targetColumn = relation.getCaller();
                                if(targetColumn != null) {
                                        targetColumn.setName(idNameMap.get(targetColumn.getId()));
                                }
                                sourceColumns = relation.getCallees();
                                if(sourceColumns!=null){
                                        for(sourceColumn sourceColumn: sourceColumns){
                                                sourceColumn.setName(idNameMap.get(sourceColumn.getId()));
                                        }
                                }
                        }
                }


                return instance;
        }

        private dataflow filterDataflowCoordinate(dataflow instance) {
                List<table> tables = new ArrayList<>();
                if (instance.getResultsets() != null) {
                        for (table t : instance.getResultsets()) {
                                tables.add(t);
                        }
                }

                if (instance.getTables() != null) {
                        for (table t : instance.getTables()) {
                                tables.add(t);
                        }
                }

                if (instance.getViews() != null) {
                        for (table t : instance.getViews()) {
                                tables.add(t);
                        }
                }

                if (instance.getPaths() != null) {
                        for (table t : instance.getPaths()) {
                                tables.add(t);
                        }
                }

                if (instance.getStages() != null) {
                        for (table t : instance.getStages()) {
                                tables.add(t);
                        }
                }

                if (instance.getSequences() != null) {
                        for (table t : instance.getSequences()) {
                                tables.add(t);
                        }
                }

                if (instance.getDatasources() != null) {
                        for (table t : instance.getDatasources()) {
                                tables.add(t);
                        }
                }

                if (instance.getDatabases() != null) {
                        for (table t : instance.getDatabases()) {
                                tables.add(t);
                        }
                }

                if (instance.getSchemas() != null) {
                        for (table t : instance.getSchemas()) {
                                tables.add(t);
                        }
                }

                if (instance.getStreams() != null) {
                        for (table t : instance.getStreams()) {
                                tables.add(t);
                        }
                }

                if (instance.getVariables() != null) {
                        for (table t : instance.getVariables()) {
                                tables.add(t);
                        }
                }

                for(table table: tables){
                        table.clearCoordinate();
                        if(table.getColumns()!=null){
                                for(column column: table.getColumns()){
                                        column.clearCoordinate();
                                }
                        }
                }
                if(instance.getPackages()!=null){
                        for(oraclePackage oraclePackage: instance.getPackages()){
                                oraclePackage.setCoordinate(null);
                                if(oraclePackage.getProcedures()!=null){
                                        for(procedure procedure: oraclePackage.getProcedures()){
                                                procedure.setCoordinate(null);
                                                for(argument argument: procedure.getArguments()){
                                                        argument.setCoordinate(null);
                                                }
                                        }
                                }
                        }
                }
                if(instance.getProcedures()!=null){
                        for(procedure procedure: instance.getProcedures()){
                                procedure.setCoordinate(null);
                                for(argument argument: procedure.getArguments()){
                                        argument.setCoordinate(null);
                                }
                        }
                }
                if (instance.getProcesses() != null) {
                        for (process process : instance.getProcesses()) {
                                process.setCoordinate(null);
                        }
                }

                if(instance.getRelationships()!=null){
                        for(relationship relation: instance.getRelationships()){
                                targetColumn targetColumn = relation.getTarget();
                                if(targetColumn != null) {
                                        targetColumn.setCoordinate(null);
                                }
                                List<sourceColumn> sourceColumns = relation.getSources();
                                if(sourceColumns!=null){
                                        for(sourceColumn sourceColumn: sourceColumns){
                                                sourceColumn.setCoordinate(null);
                                        }
                                }
                                targetColumn = relation.getCaller();
                                if(targetColumn != null) {
                                        targetColumn.setCoordinate(null);
                                }
                                sourceColumns = relation.getCallees();
                                if(sourceColumns!=null){
                                        for(sourceColumn sourceColumn: sourceColumns){
                                                sourceColumn.setCoordinate(null);
                                        }
                                }
                        }
                }

                return instance;
        }

        /**
         * Read a sqlflow-sharded manifest's source records into {@link SqlInfo}s (for the
         * convertSQL / text-constructor path). Relative source paths resolve against
         * {@code baseDir}; without a base directory the shard files cannot be located, so
         * nothing is added (a manifest passed as inline text with no file location simply
         * cannot be followed to its shards). Unavailable records are skipped. Block-compressed
         * sources are handled on the generateDataFlow path, not here.
         */
        private void appendShardedSourceSqlInfos(String manifestSql, String baseDir, String fileName,
                        List<SqlInfo> sqlInfos) {
                if (baseDir == null) {
                        return;
                }
                Map sqlflow = (Map) JSON.parseObject(manifestSql);
                boolean block = "block".equals(sqlflow.get("sourceCompression"));
                List<Map> servers = (List<Map>) sqlflow.get("servers");
                if (servers == null) {
                        return;
                }
                for (Map server : servers) {
                        String dbVendor = (String) server.get("dbVendor");
                        String serverName = (String) server.get("name");
                        // A sharded export is organized either as catalog shards
                        // (servers[].databases[]) or as schema shards
                        // (servers[].schemas[], the natural shape for schema-topology
                        // vendors like Oracle). Both carry a per-shard `source` pointer;
                        // prefer schema shards when present, treating an empty list as
                        // absent so a manifest with "databases":[] alongside schemas[]
                        // still loads. Handling only `databases` silently dropped every
                        // source record of a schema-topology manifest -> empty lineage.
                        List<Map> shards = (List<Map>) server.get("schemas");
                        if (shards == null || shards.isEmpty()) {
                                shards = (List<Map>) server.get("databases");
                        }
                        if (shards == null || shards.isEmpty()) {
                                continue;
                        }
                        for (Map shard : shards) {
                                appendShardedSourceRecords((Map) shard.get("source"), baseDir, block,
                                                dbVendor, serverName, sqlInfos, SqlflowNameForm.declared(sqlflow));
                        }
                }
        }

        /**
         * Read one shard's source jsonl (catalog- or schema-topology) into SqlInfos.
         * Shared by the {@code databases[]} and {@code schemas[]} shard shapes so a
         * schema-topology manifest loads its source SQL identically to a
         * catalog-topology one.
         */
        private void appendShardedSourceRecords(Map source, String baseDir, boolean block,
                        String dbVendor, String serverName, List<SqlInfo> sqlInfos, IdentifierInputForm nameForm) {
                if (source == null) {
                        return;
                }
                String sourcePath = (String) source.get("path");
                if (sourcePath == null) {
                        return;
                }
                File sourceFile = new File(baseDir, sourcePath);
                String content = block ? readGzipContent(sourceFile.getAbsolutePath())
                                : SQLUtil.getFileContent(sourceFile.getAbsolutePath());
                if (content == null) {
                        return;
                }
                String[] lines = content.split("\\r?\\n");
                EDbVendor vendor = EDbVendor.valueOf(dbVendor);
                boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
                boolean supportSchema = TSQLEnv.supportSchema(vendor);

                for (int j = 0; j < lines.length; j++) {
                        String line = lines[j].trim();
                        if (line.isEmpty()) {
                                continue;
                        }
                        try {
                                Map rec = (Map) JSON.parseObject(line);
                                String sc = (String) rec.get("sourceCode");
                                if (sc != null && !sc.isEmpty() && !isSourceUnavailable(rec)) {
                                        SqlInfo info = new SqlInfo();
                                        info.setSql(sc);
                                        info.setFileName(sourceFile.getName());
                                        info.setFilePath(sourceFile.getAbsolutePath());
                                        info.setOriginIndex(j);
                                        info.setDbVendor(dbVendor);
                                        info.setServer(serverName);

                                        String database = (String) rec.get("database");
                                        String schema = (String) rec.get("schema");
                                        StringBuilder groupBuilder = new StringBuilder();
                                        if (supportCatalog) {
                                                if (database.indexOf(".") != -1) {
                                                        database = SQLUtil.quoteDottedName(vendor, ESQLDataObjectType.dotCatalog, database);
                                                }
                                                groupBuilder.append(database);
                                        }
                                        if (supportSchema) {
                                                if (schema.indexOf(".") != -1) {
                                                        schema = SQLUtil.quoteDottedName(vendor, ESQLDataObjectType.dotSchema, schema);
                                                }
                                                if (groupBuilder.length() > 0) {
                                                        groupBuilder.append(".");
                                                }
                                                groupBuilder.append(schema);
                                        }
                                        info.setGroup(groupBuilder.toString());
                                        info.setGroupNameForm(nameForm == IdentifierInputForm.CATALOG_STORED ? nameForm : null);

                                        sqlInfos.add(info);
                                }
                        } catch (Exception e) {
                                logger.warn("Parse sharded source jsonl line failed.", e);
                        }
                }
        }

        /** Decompress a gzip/block-compressed source shard to its text, or null on failure. */
        private static String readGzipContent(String path) {
                File f = new File(path);
                if (!f.exists()) {
                        return null;
                }
                StringBuilder sb = new StringBuilder();
                try (java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.InputStreamReader(
                                new java.util.zip.GZIPInputStream(new java.io.FileInputStream(f)),
                                java.nio.charset.StandardCharsets.UTF_8))) {
                        String line;
                        while ((line = reader.readLine()) != null) {
                                sb.append(line).append('\n');
                        }
                } catch (IOException e) {
                        logger.warn("Failed to read gzip source shard: " + path, e);
                        return null;
                }
                return sb.toString();
        }

        /**
         * True when a sqlflow source record declares its DDL body unavailable
         * ({@code sourceUnavailable:true}). Robust to the JSON value arriving as a
         * boolean or a string. A record with no such field is available.
         */
        static boolean isSourceUnavailable(Map record) {
                if (record == null) {
                        return false;
                }
                Object v = record.get("sourceUnavailable");
                if (v instanceof Boolean) {
                        return (Boolean) v;
                }
                return v != null && "true".equalsIgnoreCase(v.toString().trim()); // non-identifier-compare: JSON boolean literal, not a DB name
        }

        /**
         * The form of each group's names, by the group's sql hash: {@code CATALOG_STORED} for the stored
         * database and schema of a metadata query whose file declares it; absent for SQL spellings. The
         * group text stays the bare name; the form goes to ModelBindingManager with it.
         */
        private final Map<String, IdentifierInputForm> groupNameForms = new HashMap<String, IdentifierInputForm>();

        private void appendSqlInfo(Map<String, Pair3<StringBuilder, AtomicInteger, String>> databaseMap, int index,
                        SqlInfo sqlInfo, Map queryObject) {
                // A lone query object may carry its input's declaration.
                appendSqlInfo(databaseMap, index, sqlInfo, queryObject,
                                queryObject == null ? IdentifierInputForm.SQL_LEXICAL : SqlflowNameForm.declared(queryObject));
        }

        /**
         * @param nameForm how the input declares its names; the query's {@code database} and
         *        {@code schema} form its group in that form
         */
        private void appendSqlInfo(Map<String, Pair3<StringBuilder, AtomicInteger, String>> databaseMap, int index,
                        SqlInfo sqlInfo, Map queryObject, IdentifierInputForm nameForm) {
                if (queryObject == null) {
                        return;
                }
                EDbVendor vendor = option.getVendor();
                if (!SQLUtil.isEmpty(sqlInfo.getDbVendor())) {
                        vendor = EDbVendor.valueOf(sqlInfo.getDbVendor());
                }

                boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
                boolean supportSchema = TSQLEnv.supportSchema(vendor);

                String groupName = (String) queryObject.get("groupName");
                if (DlineageUtil.isProcedureExcluded(groupName)) {
                        return;
                }

                // sourceUnavailable: the DDL body was not retrieved (encrypted proc,
                // permission denied). Any sourceCode present is a placeholder or a
                // reason string, not the real definition, so it must NOT be parsed as
                // live SQL — doing so fabricates lineage from text that is not the
                // object's body.
                if (isSourceUnavailable(queryObject)) {
                        return;
                }

                String content = (String) queryObject.get("sourceCode");
                if (SQLUtil.isEmpty(content)) {
                        return;
                }
                StringBuilder builder = new StringBuilder();
                if (supportCatalog) {
                        String database = (String) queryObject.get("database");
                        if (database.indexOf(".") != -1) {
                                database = SQLUtil.quoteDottedName(vendor, ESQLDataObjectType.dotCatalog, database);
                        }
                        builder.append(database);
                }
                if (supportSchema) {
                        String schema = (String) queryObject.get("schema");
                        if (schema.indexOf(".") != -1) {
                                schema = SQLUtil.quoteDottedName(vendor, ESQLDataObjectType.dotSchema, schema);
                        }
                        if (builder.length() > 0) {
                                builder.append(".");
                        }
                        builder.append(schema);
                }
                String group = builder.toString();
                String sqlHash = SHA256.getMd5(content);
                String hash = SHA256.getMd5(sqlHash);
                if (!databaseMap.containsKey(sqlHash)) {
                        databaseMap.put(sqlHash,
                                        new Pair3<StringBuilder, AtomicInteger, String>(new StringBuilder(), new AtomicInteger(), group));
                        if (nameForm == IdentifierInputForm.CATALOG_STORED) {
                                groupNameForms.put(sqlHash, nameForm);
                        }
                }
                String delimiterChar = String.valueOf(TGSqlParser.getDelimiterChar(option.getVendor()));
                StringBuilder buffer = new StringBuilder(content);
                if (content.trim().endsWith(delimiterChar) || content.trim().endsWith(";")) {
                        buffer.append("\n");
                } else if(vendor == EDbVendor.dbvredshift
                                || vendor == EDbVendor.dbvgaussdb
                                || vendor == EDbVendor.dbvedb
                                || vendor == EDbVendor.dbvpostgresql
                                || vendor == EDbVendor.dbvmysql
                                || vendor == EDbVendor.dbvteradata){
                        buffer.append("\n\n-- " + TBaseType.sqlflow_stmt_delimiter_str + "\n\n");
                } else{
                        SQLUtil.endTrim(buffer);
                        buffer.append(";").append("\n");
                }

                int lineStart = databaseMap.get(sqlHash).first.toString().split("\n", -1).length - 1;
                if (databaseMap.get(sqlHash).first.toString().length() == 0) {
                        lineStart = 0;
                }
                if (commentBindingCollector != null) commentBindingCollector.register(sqlHash, buffer.toString(),
                databaseMap.get(sqlHash).first.length(), index, sqlInfo.getFileName(), true);
        databaseMap.get(sqlHash).first.append(buffer.toString());
                SqlInfo sqlInfoItem = new SqlInfo();
                sqlInfoItem.setServer(sqlInfo.getServer());
                sqlInfoItem.setDbVendor(sqlInfo.getDbVendor());
                sqlInfoItem.setFileName(sqlInfo.getFileName());
                sqlInfoItem.setFilePath(sqlInfo.getFilePath());
                sqlInfoItem.setSql(buffer.toString());
                sqlInfoItem.setOriginIndex(index);
                sqlInfoItem.setOriginLineStart(0);
                sqlInfoItem.setOriginLineEnd(buffer.toString().split("\n", -1).length - 1);
                sqlInfoItem.setIndex(databaseMap.get(sqlHash).second.getAndIncrement());
                sqlInfoItem.setLineStart(lineStart);
                sqlInfoItem.setLineEnd(databaseMap.get(sqlHash).first.toString().split("\n", -1).length - 1);
                sqlInfoItem.setGroup(group);
                sqlInfoItem.setHash(hash);

                if (!sqlInfoMap.containsKey(hash)) {
                        sqlInfoMap.put(hash, new ArrayList<SqlInfo>());
                }
                sqlInfoMap.get(hash).add(sqlInfoItem);
        }

        private void readGzipBlockSource(String fullPath, Map<String, Pair3<StringBuilder, AtomicInteger, String>> databaseMap, SqlInfo sqlInfo,
                        IdentifierInputForm nameForm) {
                try (FileInputStream fis = new FileInputStream(fullPath);
                         GZIPInputStream gzis = new GZIPInputStream(fis);
                         BufferedReader reader = new BufferedReader(new InputStreamReader(gzis, "UTF-8"))) {
                        String line;
                        int j = 0;
                        while ((line = reader.readLine()) != null) {
                                line = line.trim();
                                if (line.isEmpty()) {
                                        continue;
                                }
                                try {
                                        Map sourceObject = (Map) JSON.parseObject(line);
                                        String sourceCode = (String) sourceObject.get("sourceCode");
                                        if (sourceCode != null && !sourceCode.isEmpty()
                                                        && !isSourceUnavailable(sourceObject)) {
                                                SqlInfo sourceSqlInfo = new SqlInfo();
                                                sourceSqlInfo.setFileName(sqlInfo.getFileName());
                                                sourceSqlInfo.setFilePath(sqlInfo.getFilePath());
                                                sourceSqlInfo.setSql(sourceCode);
                                                sourceSqlInfo.setOriginIndex(j);
                                                // Pass the record (not null): appendSqlInfo dereferences it
                                                // for groupName/database/schema; null NPE'd and the catch
                                                // silently discarded every source record on this path.
                                                appendSqlInfo(databaseMap, j, sourceSqlInfo, sourceObject, nameForm);
                                        }
                                } catch (Exception e) {
                                        logger.warn("Parse gzip source jsonl line failed.", e);
                                }
                                j++;
                        }
                } catch (Exception e) {
                        logger.warn("Read gzip source file failed: " + fullPath, e);
                }
        }

        static String getTextOutput(dataflow dataflow) {
                StringBuffer buffer = new StringBuffer();
                List<relationship> relations = dataflow.getRelationships();
                if (relations != null) {
                        for (int i = 0; i < relations.size(); i++) {
                                relationship relation = relations.get(i);
                                targetColumn target = relation.getTarget();
                                List<sourceColumn> sources = relation.getSources();
                                if (target != null && sources != null && sources.size() > 0) {
                                        buffer.append(target.getColumn()).append(" depends on: ");
                                        Set<String> columnSet = new LinkedHashSet<String>();
                                        for (int j = 0; j < sources.size(); j++) {
                                                sourceColumn sourceColumn = sources.get(j);
                                                String columnName = sourceColumn.getColumn();
                                                if (sourceColumn.getParent_name() != null && sourceColumn.getParent_name().length() > 0) {
                                                        columnName = sourceColumn.getParent_name() + "." + columnName;
                                                }
                                                columnSet.add(columnName);
                                        }
                                        String[] columns = columnSet.toArray(new String[0]);
                                        for (int j = 0; j < columns.length; j++) {
                                                buffer.append(columns[j]);
                                                if (j == columns.length - 1) {
                                                        buffer.append("\n");
                                                } else
                                                        buffer.append(", ");
                                        }
                                }
                        }
                }
                return buffer.toString();
        }

        private String mergeRelationType(List<Pair<sourceColumn, List<String>>> typePaths) {
                RelationshipType relationType = RelationshipType.join;
                for (int i = 0; i < typePaths.size(); i++) {
                        List<String> path = typePaths.get(i).second;
                        RelationshipType type = RelationshipType.valueOf(getRelationType(path));
                        if (type.ordinal() < relationType.ordinal()) {
                                relationType = type;
                        }
                }
                return relationType.name();
        }

        private String getRelationType(List<String> typePaths) {
                if (typePaths.contains("join"))
                        return "join";
                if (typePaths.contains("fdr"))
                        return "fdr";
                if (typePaths.contains("frd"))
                        return "frd";
                if (typePaths.contains("fddi"))
                        return "fddi";
                return "fdd";
        }

        public dataflow getSimpleDataflow(dataflow instance, boolean simpleOutput) throws Exception {
                return getSimpleDataflow(instance, simpleOutput, Arrays.asList("fdd"));
        }

        public dataflow getSimpleDataflow(dataflow instance, boolean simpleOutput, List<String> types) throws Exception {
                ModelBindingManager.setGlobalVendor(option.getVendor());
                allMap.clear();
                targetTables.clear();
                resultSetMap.clear();
                tableMap.clear();
                viewMap.clear();
                cursorMap.clear();
                variableMap.clear();
                fileMap.clear();
                stageMap.clear();
                sequenceMap.clear();
                dataSourceMap.clear();
                databaseMap.clear();
                schemaMap.clear();
                streamMap.clear();
                dataflow simple = new dataflow();
        simple.setCommentBindings(instance.getCommentBindings());
                List<relationship> simpleRelations = new ArrayList<relationship>();
                List<relationship> relations = instance.getRelationships();
                if (instance.getResultsets() != null) {
                        for (table t : instance.getResultsets()) {
                                resultSetMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                        if (option.isSimpleRetainIntermediate()) {
                                for (table t : instance.getResultsets()) {
                                        if (t.isFunction() || t.getProcedureId() != null) {
                                                t.setIsTarget("true");
                                        }
                                }
                        }
                }

                if (instance.getTables() != null) {
                        for (table t : instance.getTables()) {
                                tableMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (instance.getViews() != null) {
                        for (table t : instance.getViews()) {
                                viewMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (instance.getPaths() != null) {
                        for (table t : instance.getPaths()) {
                                fileMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (instance.getStages() != null) {
                        for (table t : instance.getStages()) {
                                stageMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }
                
                if (instance.getSequences() != null) {
                        for (table t : instance.getSequences()) {
                                sequenceMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (instance.getDatasources() != null) {
                        for (table t : instance.getDatasources()) {
                                dataSourceMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (instance.getDatabases() != null) {
                        for (table t : instance.getDatabases()) {
                                databaseMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (instance.getSchemas() != null) {
                        for (table t : instance.getSchemas()) {
                                schemaMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (instance.getStreams() != null) {
                        for (table t : instance.getStreams()) {
                                streamMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (instance.getVariables() != null) {
                        for (table t : instance.getVariables()) {
                                if(SubType.cursor.name().equals(t.getSubType())){
                                        cursorMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                }
                                else {
                                        variableMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                                }
                                allMap.put(t.getId().toLowerCase(Locale.ROOT), t);
                        }
                }

                if (relations != null) {
                        
                        List<relationship> filterRelations = new ArrayList<>();
                        for (relationship relationElem : relations) {
                                if (!types.contains(relationElem.getType())) {
                                        if (option.isSimpleRetainIntermediate()
                                                        && RelationshipType.call.name().equals(relationElem.getType())) {
                                                filterRelations.add(relationElem);
                                        }
                                        continue;
                                }
                                else {
                                        filterRelations.add(relationElem);
                                }
                        }
                        
                        relations = filterRelations;
                        
                        outputColumnsById = DlineageUtil.outputColumnsById(instance);
                        Map<String, Set<relationship>> targetIdRelationMap = new LinkedHashMap<String, Set<relationship>>();
                        for (relationship relation : relations) {
                                if (relation.getTarget() != null) {
                                        String key = relation.getTarget().getParent_id() + "." + relation.getTarget().getId();
                                        if (!targetIdRelationMap.containsKey(key)) {
                                                targetIdRelationMap.put(key, new TreeSet<relationship>(new Comparator<relationship>() {
                                                        @Override
                                                        public int compare(relationship o1, relationship o2) {
                                                                return o1.getId().compareTo(o2.getId());
                                                        }
                                                }));
                                        }
                                        targetIdRelationMap.get(key).add(relation);
                                }
                        }

                        Iterator<String> keys = targetIdRelationMap.keySet().iterator();
                        while (keys.hasNext()) {
                                String key = keys.next();
                                if (targetIdRelationMap.get(key).size() > 500) {
                                        keys.remove();
                                }
                        }

                        for (relationship relationElem : relations) {
                                if (RelationshipType.call.name().equals(relationElem.getType())) {
                                        continue;
                                }
                                if (RelationshipType.er.name().equals(relationElem.getType())) {
                                        continue;
                                }
                                targetColumn target = relationElem.getTarget();
                                String targetParent = target.getParent_id();
                                if (isTarget(instance, targetParent, simpleOutput)) {
                                        List<Pair<sourceColumn, List<String>>> relationSources = new ArrayList<Pair<sourceColumn, List<String>>>();
                                        Map<sourceColumn, String> filterClauses = new IdentityHashMap<sourceColumn, String>();
                                        findSourceRelations(target, instance, targetIdRelationMap, relationElem, relationSources,
                                                        filterClauses, new String[] { relationElem.getType() }, simpleOutput);
                                        if (relationSources.size() > 0) {
                                                Map<sourceColumn, List<Pair<sourceColumn, List<String>>>> columnMap = new LinkedHashMap<sourceColumn, List<Pair<sourceColumn, List<String>>>>();
                                                for (Pair<sourceColumn, List<String>> t : relationSources) {
                                                        sourceColumn key = ((Pair<sourceColumn, List<String>>) t).first;
                                                        if (!columnMap.containsKey(key)) {
                                                                columnMap.put(key, new ArrayList<Pair<sourceColumn, List<String>>>());
                                                        }
                                                        columnMap.get(key).add(t);
                                                }
                                                Iterator<sourceColumn> iter = columnMap.keySet().iterator();
                                                Map<String, List<sourceColumn>> relationSourceMap = new LinkedHashMap<String, List<sourceColumn>>();
                                                Set<sourceColumn> passthroughColumns = new HashSet<sourceColumn>();
                                                while (iter.hasNext()) {
                                                        sourceColumn key = iter.next();
                                                        String relationType = mergeRelationType(columnMap.get(key));
                                                        // The paths of that type justify the edge (Mantis 4867): its source is their copy, with
                                                        // their transforms, clause and passthrough tag, not those of a path of another type.
                                                        List<Pair<sourceColumn, List<String>>> typePaths = new ArrayList<Pair<sourceColumn, List<String>>>();
                                                        for (Pair<sourceColumn, List<String>> typePath : columnMap.get(key)) {
                                                                if (relationType.equals(getRelationType(typePath.second))) {
                                                                        typePaths.add(typePath);
                                                                }
                                                        }
                                                        sourceColumn column = typePaths.get(0).first;
                                                        if (RelationshipType.fdr.name().equals(relationType)) {
                                                                applyFilterClause(column, typePaths, filterClauses);
                                                        }
                                                        if (!relationSourceMap.containsKey(relationType)) {
                                                                relationSourceMap.put(relationType, new ArrayList<sourceColumn>());
                                                        }
                                                        relationSourceMap.get(relationType).add(column);
                                                        // Mark columns that reached this target through an assumed passthrough edge.
                                                        for (Pair<sourceColumn, List<String>> typePath : typePaths) {
                                                                if (typePath.second != null
                                                                        && typePath.second.contains(EffectType.external_script_passthrough.name())) {
                                                                        passthroughColumns.add(column);
                                                                        break;
                                                                }
                                                        }
                                                }

                                                Iterator<String> sourceIter = relationSourceMap.keySet().iterator();
                                                while (sourceIter.hasNext()) {
                                                        String relationType = sourceIter.next();
                                                        relationship simpleRelation = (relationship) relationElem.clone();
                                                        List<sourceColumn> groupSources = relationSourceMap.get(relationType);
                                                        simpleRelation.setSources(groupSources);
                                                        simpleRelation.setType(relationType);
                                                        simpleRelation.setId(String.valueOf(++ModelBindingManager.get().RELATION_ID));
                                                        // If any source in this group reached the target through an assumed external-
                                                        // script passthrough edge, tag the flattened edge so simple output does not
                                                        // present assumed lineage as proven.
                                                        for (sourceColumn groupSource : groupSources) {
                                                                if (passthroughColumns.contains(groupSource)) {
                                                                        simpleRelation.setEffectType(EffectType.external_script_passthrough.name());
                                                                        break;
                                                                }
                                                        }
                                                        simpleRelations.add(simpleRelation);
                                                }
                                        }
                                }
                        }
                }

                simple.setProcedures(instance.getProcedures());
                simple.setPackages(instance.getPackages());
                simple.setProcesses(instance.getProcesses());
                simple.setErrors(instance.getErrors());

                List<table> tables = new ArrayList<table>();
                for (table t : instance.getTables()) {
                        if (!SQLUtil.isTempTable(t)) {
                                tables.add(t);
                        }
                        else {
                                if (option.isIgnoreTemporaryTable()) {
                                        continue;
                                }
                                else {
                                        tables.add(t);
                                }
                        }
                }
                simple.setStages(instance.getStages());
                simple.setSequences(instance.getSequences());
                simple.setDatasources(instance.getDatasources());
                simple.setStreams(instance.getStreams());
                simple.setPaths(instance.getPaths());
                simple.setTables(tables);
                simple.setViews(instance.getViews());
                if(option.isSimpleShowVariable()) {
                        simple.setVariables(instance.getVariables());
                }
                else if(option.isSimpleShowCursor()) {
                        simple.setVariables(instance.getVariables().stream().filter(t->SubType.cursor.name().equals(t.getSubType())).collect(Collectors.toList()));
                }
        else{
            simple.setVariables(new ArrayList());
        }

        if (option.isSimpleRetainIntermediate() && instance.getVariables() != null) {
                        for (table var : instance.getVariables()) {
                                if (var.isTarget()) {
                    simple.getVariables().add(var);
                                }
                        }
                }
                if (instance.getResultsets() != null) {
                        List<table> resultSets = new ArrayList<table>();
                        for (int i = 0; i < instance.getResultsets().size(); i++) {
                                table resultSet = instance.getResultsets().get(i);
                                if (isTargetResultSet(instance, resultSet.getId(), simpleOutput)) {
                                        // special handle function #524 #296
                                        resultSets.add(resultSet);
                                }
                                else if (option.isSimpleRetainIntermediate() && (resultSet.isFunction() || resultSet.getProcedureId() != null)) {
                                        resultSet.setIsTarget("true");
                                        resultSets.add(resultSet);
                                }
                        }
                        simple.setResultsets(resultSets);
                }

                List<table> functions = new ArrayList<table>();
                if (option.isShowCallRelation()) {
                        for (int i = 0; i < relations.size(); i++) {
                                relationship relationElem = relations.get(i);
                                if (!RelationshipType.call.name().equals(relationElem.getType())) {
                                        continue;
                                }
                                simpleRelations.add(relationElem);
                                for (sourceColumn callee : relationElem.getCallees()) {
                                        String calleeId = callee.getId();
                                        if (resultSetMap.containsKey(calleeId)) {
                                                table function = resultSetMap.get(calleeId);
                                                function.setIsTarget("true");
                                                functions.add(function);
                                        }
                                }
                        }
                }

                if (option.isShowERDiagram()) {
                        for (int i = 0; i < relations.size(); i++) {
                                relationship relationElem = relations.get(i);
                                if (!RelationshipType.er.name().equals(relationElem.getType())) {
                                        continue;
                                }
                                simpleRelations.add(relationElem);
                                for (sourceColumn callee : relationElem.getCallees()) {
                                        String calleeId = callee.getId();
                                        if (resultSetMap.containsKey(calleeId)) {
                                                table function = resultSetMap.get(calleeId);
                                                function.setIsTarget("true");
                                                functions.add(function);
                                        }
                                }
                        }
                }
                
                if (option.isSimpleRetainIntermediate() && !option.isShowCallRelation()) {
                        for (int i = 0; i < relations.size(); i++) {
                                relationship relationElem = relations.get(i);
                                if (RelationshipType.call.name().equals(relationElem.getType())) {
                                        simpleRelations.add(relationElem);
                                }
                        }
                }

                if (!functions.isEmpty()) {
                        if (simple.getResultsets() == null) {
                                simple.setResultsets(functions);
                        } else {
                                simple.getResultsets().addAll(functions);
                        }
                }

                simple.setRelationships(simpleRelations);
                simple.setOrientation(instance.getOrientation());

                targetTables.clear();
                resultSetMap.clear();
                tableMap.clear();
                viewMap.clear();
                cursorMap.clear();
                variableMap.clear();
                fileMap.clear();
                stageMap.clear();
                dataSourceMap.clear();
                databaseMap.clear();
                schemaMap.clear();
                streamMap.clear();
        CommentBindingProjection.retain(simple);
                // the simple output folds hops and drops coordinates, so two relationships of the full output can meet as one
                if (!endpointLabelsDeferred) {
                        DataflowUtility.labelEndpoints(simple);
                }
                return simple;
        }

        private void findSourceRelations(targetColumn target, dataflow instance, Map<String, Set<relationship>> sourceIdRelationMap,
                        relationship targetRelation, List<Pair<sourceColumn, List<String>>> relationSources,
                        Map<sourceColumn, String> filterClauses, String[] pathTypes, boolean simpleOutput) {
                findStarSourceRelations(target, instance, null, false, sourceIdRelationMap, targetRelation, relationSources,
                                pathTypes, new HashMap<String, Integer>(), new LinkedHashSet<transform>(), new LinkedHashSet<candidateTable>(),
                                0, simpleOutput, null, filterClauses);
        }

        /**
         * The rank {@link #mergeRelationType} gives a path ({@link #getRelationType}, as a {@link RelationshipType}
         * ordinal): the lower rank wins, so a value path (fdd) beats a path through a filter (fdr).
         */
        private int pathRank(String[] pathTypes) {
                return RelationshipType.valueOf(getRelationType(Arrays.asList(pathTypes))).ordinal();
        }

        /**
         * The clause of the filter a folded source reaches its target through (Mantis 4866): the clauseType of the first
         * fdr hop, from the target, whose source is a WHERE, ON or HAVING operand. {@code t.x -fdd-> ABS.ABS -fdr(where)->
         * RelationRows} folds to {@code t.x -> RelationRows}, and t.x is read in that WHERE as it is in {@code WHERE x > 5}.
         */
        private static String filterHopClause(relationship relation, sourceColumn source, String inherited) {
                if (inherited != null || !RelationshipType.fdr.name().equals(relation.getType())) {
                        return inherited;
                }
                String clause = source.getClauseType();
                return ESqlClause.where.name().equals(clause) || ESqlClause.joinCondition.name().equals(clause)
                                || ESqlClause.having.name().equals(clause) ? clause : null;
        }

        /**
         * Gives a folded source with no clause of its own the clause of the filter one of its paths passed through
         * ({@link #filterHopClause}). The caller asks only for an fdr edge: a source that also reaches the target as a
         * value is an fdd source, and a value has no clause.
         */
        private static void applyFilterClause(sourceColumn column, List<Pair<sourceColumn, List<String>>> typePaths,
                        Map<sourceColumn, String> filterClauses) {
                if (column.getClauseType() != null) {
                        return;
                }
                for (Pair<sourceColumn, List<String>> typePath : typePaths) {
                        String clause = filterClauses.get(typePath.first);
                        if (clause != null) {
                                column.setClauseType(clause);
                                return;
                        }
                }
        }

        /**
         * @param positionUnproven whether the {@code *} the walk follows is read at a position its members' unknown
         *        order cannot tell ({@link sourceColumn#isPositionUnproven()}): the {@code *} of a table that fills it
         *        stands for it, never a column of that table named like {@code starRelationTarget} (Mantis 4856)
         * @param paths the best {@link #pathRank} each intermediate node was reached with in this walk, per star state the
         *        walk carries past it: a node is walked again only by a better path, so neither the type a source gets nor
         *        the sources reached depend on which path came first (Mantis 4867)
         * @param filterClause the clause of the filter the walk passed through ({@link #filterHopClause})
         * @param filterClauses receives that clause for each folded source copy, applied once the copy's relation type is
         *        known ({@link #applyFilterClause})
         */
        private void findStarSourceRelations(targetColumn target, dataflow instance, targetColumn starRelationTarget,
                        boolean positionUnproven, Map<String, Set<relationship>> sourceIdRelationMap, relationship targetRelation,
                        List<Pair<sourceColumn, List<String>>> relationSources, String[] pathTypes, Map<String, Integer> paths,
                        Set<transform> transforms, Set<candidateTable> candidateTables, int level, boolean simpleOutput,
                        String filterClause, Map<sourceColumn, String> filterClauses) {
                if (targetRelation != null && targetRelation.getSources() != null) {

                        //获取source为*的Column Parent
                        String starParentId = null;
                        // the parents of every * the relation reads, when the walk's * has no member proven at the position
                        Set<String> starParentIds = positionUnproven ? new HashSet<String>() : Collections.<String>emptySet();
                        for (int i = 0; i < targetRelation.getSources().size(); i++) {
                                sourceColumn source = targetRelation.getSources().get(i);
                                if (starRelationTarget != null && DlineageUtil.isStarEndpoint(outputColumnsById, source.getId(), source.getColumn())) {
                                        starParentId = source.getParent_id();
                                        if (positionUnproven) {
                                                starParentIds.add(starParentId);
                                        }
                                }
                        }

                        for (int i = 0; i < targetRelation.getSources().size(); i++) {
                                sourceColumn source = targetRelation.getSources().get(i);
                                if (positionUnproven && source.getParent_id() != null && starParentIds.contains(source.getParent_id())
                                                && !resultSetMap.containsKey(source.getParent_id().toLowerCase(Locale.ROOT))
                                                && !DlineageUtil.isStarEndpoint(outputColumnsById, source.getId(), source.getColumn())) {
                                        continue;
                                }
                                if (starRelationTarget != null && !DlineageUtil.isStarEndpoint(outputColumnsById, source.getId(), source.getColumn())
                                                && !DlineageUtil.sameColumnPath(starRelationTarget.getColumn(), source.getColumn())) {
                                        table parent = allMap.get(source.getParent_id());
                                        if (parent != null && isFunction(parent)) {
                                                // function返回值未知，不对星号做处理
                                        } 
                                        else if (parent == null) {
                                                continue;
                                        } else if(starParentId!=null && starParentId.equals(parent.getId())){
                                                //如果source和 * column的parent相同，则跳过
                                                continue;
                                        }
                                }

                                String sourceColumnId = source.getId();
                                String sourceParentId = source.getParent_id();
                                if (sourceParentId == null || sourceColumnId == null) {
                                        continue;
                                }
                                String hopClause = filterHopClause(targetRelation, source, filterClause);
                                if (isTarget(instance, sourceParentId, simpleOutput)) {
                                        List<transform> transforms2 = new ArrayList<transform>(transforms.size());
                                        transforms2.addAll(transforms);
                                        Collections.reverse(transforms2);
                                        
                                        List<candidateTable> candidateTables2 = new ArrayList<candidateTable>(candidateTables.size());
                                        candidateTables2.addAll(candidateTables);
                                        
                                        sourceColumn sourceColumnCopy = DlineageUtil.copySourceColumn(source);
                                        if (hopClause != null) {
                                                filterClauses.put(sourceColumnCopy, hopClause);
                                        }
                                        for (transform t : transforms2) {
                                                sourceColumnCopy.addTransform(t);
                                        }
                                        
                                        for (candidateTable t : candidateTables2) {
                                                sourceColumnCopy.addCandidateParent(t);
                                        }

                                        // A STRUCT field node folds onto the source its path reaches, whatever either one is named:
                                        // STRUCT(customer.name AS who) gives buyer.who <- customer.name, and the path of the full output
                                        // through the constructor's field is the proof. A test of the last part of the two names dropped
                                        // every field that renames what it reads (nested-access plan, section 14.6).
                                        relationSources.add(new Pair<sourceColumn, List<String>>(sourceColumnCopy, Arrays.asList(pathTypes)));
                                } else {
                                        Set<relationship> sourceRelations = sourceIdRelationMap
                                                        .get(source.getParent_id() + "." + source.getId());
                                        if (sourceRelations != null) {
                                                // the star state the walk carries past this node decides which sources it reaches there, so
                                                // a better path dominates another only in the same state
                                                boolean star = DlineageUtil.isStarEndpoint(outputColumnsById, source.getId(), source.getColumn());
                                                targetColumn nextStarTarget = !star ? null
                                                                : starRelationTarget == null ? targetRelation.getTarget() : starRelationTarget;
                                                boolean nextPositionUnproven = star && (positionUnproven || source.isPositionUnproven());
                                                String node = source.getParent_id() + "." + source.getId()
                                                                + (nextStarTarget == null ? "" : "|" + nextStarTarget.getParent_id() + "." + nextStarTarget.getId())
                                                                + (nextPositionUnproven ? "|unproven" : "");
                                                int rank = pathRank(pathTypes);
                                                Integer reached = paths.get(node);
                                                if (reached != null && reached <= rank) {
                                                        continue;
                                                } else {
                                                        paths.put(node, rank);
                                                        if (source.getTransforms() != null) {
                                                                transforms.addAll(source.getTransforms());
                                                        }
                                                        if (source.getCandidateParents() != null) {
                                                                candidateTables.addAll(source.getCandidateParents());
                                                        }
                                                }
                                                for (relationship relation : sourceRelations) {
                                                        LinkedHashSet<transform> transforms2 = new LinkedHashSet<transform>(transforms.size());
                                                        transforms2.addAll(transforms);
                                                        LinkedHashSet<candidateTable> candidateTables2 = new LinkedHashSet<candidateTable>(candidateTables.size());
                                                        candidateTables2.addAll(candidateTables);
                                                        // Carry an assumed external-script passthrough marker down the path
                                                        // (alongside the relationship type) so a flattened simple-output edge
                                                        // that traversed it can be tagged and never look proven. The marker is
                                                        // ignored by getRelationType, so type computation is unaffected.
                                                        boolean passthroughHop = EffectType.external_script_passthrough.name()
                                                                        .equals(relation.getEffectType());
                                                        String[] types = new String[pathTypes.length + (passthroughHop ? 2 : 1)];
                                                        int typeOffset = 0;
                                                        types[typeOffset++] = relation.getType();
                                                        if (passthroughHop) {
                                                                types[typeOffset++] = EffectType.external_script_passthrough.name();
                                                        }
                                                        System.arraycopy(pathTypes, 0, types, typeOffset, pathTypes.length);
                                                        if (!star) {
                                                                findStarSourceRelations(target, instance, null, false, sourceIdRelationMap, relation,
                                                                                relationSources, types, paths, transforms2, candidateTables2, level + 1, simpleOutput,
                                                                                hopClause, filterClauses);
                                                        } else {
                                                                findStarSourceRelations(target, instance, nextStarTarget, nextPositionUnproven,
                                                                                sourceIdRelationMap, relation, relationSources, types, paths, transforms,
                                                                                candidateTables2, level + 1, simpleOutput, hopClause, filterClauses);
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        private Map<String, Boolean> targetTables = new HashMap<String, Boolean>();
        /** The simple-output walk's published columns by id, for {@link DlineageUtil#isStarEndpoint}. */
        private Map<String, column> outputColumnsById = Collections.emptyMap();
        private Map<String, table> resultSetMap = new HashMap<String, table>();
        private Map<String, table> tableMap = new HashMap<String, table>();
        private Map<String, table> viewMap = new HashMap<String, table>();
        private Map<String, table> cursorMap = new HashMap<String, table>();
        private Map<String, table> variableMap = new HashMap<String, table>();
        private Map<String, table> fileMap = new HashMap<String, table>();
        private Map<String, table> stageMap = new HashMap<String, table>();
        private Map<String, table> sequenceMap = new HashMap<String, table>();
        private Map<String, table> dataSourceMap = new HashMap<String, table>();
        private Map<String, table> databaseMap = new HashMap<String, table>();
        private Map<String, table> schemaMap = new HashMap<String, table>();
        private Map<String, table> streamMap = new HashMap<String, table>();
        private Map<String, table> allMap = new HashMap<String, table>();

        private boolean isTarget(dataflow instance, String targetParentId, boolean simpleOutput) {
                if (targetTables.containsKey(targetParentId))
                        return targetTables.get(targetParentId);
                if (isTable(instance, targetParentId)) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if (isView(instance, targetParentId)) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if (isFile(instance, targetParentId)) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if (isDatabase(instance, targetParentId)) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if (isSchema(instance, targetParentId)) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if (isStage(instance, targetParentId)) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if (isSequence(instance, targetParentId)) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if (isDataSource(instance, targetParentId)) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if (isStream(instance, targetParentId)) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if (isCursor(instance, targetParentId) && option.isSimpleShowCursor()) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if ((isVariable(instance, targetParentId) || isCursor(instance, targetParentId)) && option.isSimpleShowVariable()) {
                        targetTables.put(targetParentId, true);
                        return true;
                } else if ((isVariable(instance, targetParentId) || isCursor(instance, targetParentId)) && option.isSimpleRetainIntermediate()) {
                        table var = variableMap.get(targetParentId.toLowerCase(Locale.ROOT));
                        if (var != null && var.isTarget()) {
                                targetTables.put(targetParentId, true);
                                return true;
                        }
                } else if (isTargetResultSet(instance, targetParentId, simpleOutput)) {
                        targetTables.put(targetParentId, true);
                        return true;
                }
                targetTables.put(targetParentId, false);
                return false;
        }

        private boolean isTargetResultSet(dataflow instance, String targetParent, boolean simpleOutput) {
                if (resultSetMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        table result = resultSetMap.get(targetParent.toLowerCase(Locale.ROOT));
                        boolean isTarget = result.isTarget();
                        Option option = ModelBindingManager.getGlobalOption();
                        if (option != null && option.isSqlflowIgnoreFunction() && isFunction(result)) {
                                return false;
                        }
                        if (isTarget && simpleOutput) {
                                if (option != null && option.isSimpleShowFunction() && isFunction(result)) {
                                        return true;

                                } else if (option != null && option.isSimpleShowTopSelectResultSet()) {
                                        return true;
                                }
                                if (option != null && option.isSimpleRetainIntermediate() && (isFunction(result) || result.getProcedureId() != null)) {
                                        return true;
                                }
                                if (ResultSetType.of(result.getType()) != null && option.containsResultSetType(ResultSetType.of(result.getType()))) {
                                        return true;
                                }
                        } else
                                return isTarget;
                }
                return false;
        }

        private boolean isFunction(table resultSet) {
                if("function".equals(resultSet.getType())){
                        return true;
                }
                else if("resultset".equals(resultSet.getType()) && "function".equals(resultSet.getSubType())){
                        return true;
                }
                return false;
        }

        private boolean isView(dataflow instance, String targetParent) {
                if (viewMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        return true;
                }
                return false;
        }

        private boolean isCursor(dataflow instance, String targetParent) {
                if (cursorMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        return true;
                }
                return false;
        }

        private boolean isVariable(dataflow instance, String targetParent) {
                if (variableMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        return true;
                }
                return false;
        }

        private boolean isFile(dataflow instance, String targetParent) {
                if (fileMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        return true;
                }
                return false;
        }

        private boolean isStage(dataflow instance, String targetParent) {
                if (stageMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        return true;
                }
                return false;
        }
        
        private boolean isSequence(dataflow instance, String targetParent) {
                if (sequenceMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        return true;
                }
                return false;
        }

        private boolean isDataSource(dataflow instance, String targetParent) {
                if (dataSourceMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        return true;
                }
                return false;
        }

        private boolean isDatabase(dataflow instance, String targetParent) {
                if (databaseMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        return true;
                }
                return false;
        }

        private boolean isSchema(dataflow instance, String targetParent) {
                if (schemaMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        return true;
                }
                return false;
        }

        private boolean isStream(dataflow instance, String targetParent) {
                if (streamMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        return true;
                }
                return false;
        }

        private boolean isTable(dataflow instance, String targetParent) {
                if (tableMap.containsKey(targetParent.toLowerCase(Locale.ROOT))) {
                        if (SQLUtil.isTempTable(tableMap.get(targetParent))) {
                                if (option.isIgnoreTemporaryTable()) {
                                        return false;
                                }
                        }
                        if (tableMap.get(targetParent).isFunction()) {
                                if (option != null && option.isSimpleShowFunction()) {
                                        return true;
                                } else {
                                        return false;
                                }
                        }
                        if (SubType.synonym.name().equals(tableMap.get(targetParent).getSubType())) {
                                if (option != null && option.isSimpleShowSynonym()) {
                                        return true;
                                } else {
                                        return false;
                                }
                        }
                        return true;
                } else {
                        return false;
                }
        }

        private void init() {
                arrayRelationNames.clear();
                statementOrdinals.clear();
                declarationStacks.clear();
                declarationEnds.clear();
                noOpCreates.clear();
                analyzedUnits = 0;
        if (commentBindingCollector != null) commentBindingCollector.clear();
        commentBindingCollector = option.isCollectCommentBindings() ? new CommentBindingCollector(option) : null;
                metadataErrors.clear();
                sqlInfoMap.clear();
                errorInfos.clear();
                dynamicSqlSites.clear();
                dynamicSiteIndexes.clear();
                dynamicInnerSiteIndexes.clear();
                cteSelectRelationKeys.clear();
                authoritativeEvidenceCollector.reset();
                authoritativeLineageEvidence = AuthoritativeLineageEvidence.empty();
                dynamicEvalCache.clear();
                routineCatalog = null;
                crossFileParseCache.clear();
                plsqlEvaluatedTexts.clear();
                deferredExecuteBindings.clear();
                dataflow = null;
                dataflowString = null;
                ModelBindingManager.removeGlobalDatabase();
                ModelBindingManager.removeGlobalSchema();
                ModelBindingManager.removeGlobalVendor();
                ModelBindingManager.removeGlobalSQLEnv();
                ModelBindingManager.removeGlobalHash();
                appendResultSets.clear();
                appendStarColumns.clear();
                appendTableStarColumns.clear();
                columnNameIndexCache.clear();
                resultSetColumnLookupCache.clear();
                tableColumnLookupCache.clear();
                collisionScanPending = false;
                modelManager.TABLE_COLUMN_ID = option.getStartId();
                modelManager.RELATION_ID = option.getStartId();
                modelManager.DISPLAY_ID.clear();
                modelManager.DISPLAY_NAME.clear();
                tableIds.clear();
                clickhouseExternalSourceModels.clear();
                selectIntoWithUnknownColumns.clear();
                ModelBindingManager.setGlobalVendor(option.getVendor());
                modelManager.reset();
        }

        /**
         * The ErrorInfo of one syntax error, as the analysis records it; {@code note} is appended to the message (empty
         * for an ordinary error; routine recovery marks the statements it skipped).
         */
        private ErrorInfo syntaxErrorInfo(TSyntaxError error, String note) {
                ErrorInfo errorInfo = new ErrorInfo();
                errorInfo.setErrorType(ErrorInfo.SYNTAX_ERROR);
                errorInfo.setErrorMessage(getErrorMessage(error, ErrorInfo.SYNTAX_ERROR) + note);
                errorInfo.setStartPosition(new Pair3<Long, Long, String>(error.lineNo, error.columnNo,
                                ModelBindingManager.getGlobalHash()));
                String[] segments = error.tokentext.split("\n");
                if (segments.length <= 1) {
                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(error.lineNo,
                                        error.columnNo + error.tokentext.length(),
                                        ModelBindingManager.getGlobalHash()));
                } else {
                        errorInfo.setEndPosition(
                                        new Pair3<Long, Long, String>(error.lineNo + segments.length - 1,
                                                        (long) segments[segments.length - 1].length() + 1,
                                                        ModelBindingManager.getGlobalHash()));
                }
                errorInfo.fillInfo(this);
                return errorInfo;
        }

        /**
         * "statement at lines a-b" for the statement routine recovery skipped around {@code error}: the run of ignorable
         * tokens it left there, so a skipped statement shows how far it reached (a broken statement with no terminator
         * can take the next one with it). Plain "statement" when no such token is found.
         */
        private static String skippedStatement(TGSqlParser parser, TSyntaxError error) {
                TSourceTokenList tokens = parser.sourcetokenlist;
                for (int i = 0; tokens != null && i < tokens.size(); i++) {
                        TSourceToken token = tokens.get(i);
                        if (token.lineNo != error.lineNo || token.columnNo != error.columnNo
                                        || token.tokencode != TBaseType.sqlpluscmd) {
                                continue;
                        }
                        long first = token.lineNo, last = lastLineOf(token);
                        for (int j = i - 1; j >= 0; j--) {
                                TSourceToken previous = tokens.get(j);
                                if (!previous.issolidtoken()) continue;
                                if (previous.tokencode != TBaseType.sqlpluscmd) break;
                                first = previous.lineNo;
                        }
                        for (int j = i + 1; j < tokens.size(); j++) {
                                TSourceToken next = tokens.get(j);
                                if (!next.issolidtoken()) continue;
                                if (next.tokencode != TBaseType.sqlpluscmd) break;
                                last = lastLineOf(next);
                        }
                        return first == last ? "statement at line " + first : "statement at lines " + first + "-" + last;
                }
                return "statement";
        }

        /** The line a token ends on: a string literal or comment can run over several. */
        private static long lastLineOf(TSourceToken token) {
                String text = token.getAstext();
                long line = token.lineNo;
                for (int i = 0; text != null && i < text.length(); i++) {
                        if (text.charAt(i) == '\n') line++;
                }
                return line;
        }

        private String getErrorMessage(TSyntaxError error, String errorType) {
                String s = "", hint = "Syntax error";
                if (ErrorInfo.SYNTAX_HINT.equals(errorType)) {
                        hint = "Syntax hint";
                }
                if (error.hint.length() > 0)
                        hint = error.hint;
                s = s + hint + "(" + error.errorno + ") near: " + error.tokentext;
                s = s + "(" + error.lineNo;
                s = s + "," + error.columnNo + ")";
                return s;
        }

//      boolean OLD_ENABLE_RESOLVER = TBaseType.isEnableResolver();
        private void analyzeAndOutputResult(TGSqlParser sqlparser) {
                try {
                        accessedSubqueries.clear();
                        accessedStatements.clear();
                        stmtStack.clear();
                        viewDDLMap.clear();
                        procedureDDLAliases.clear();
                        pendingOracleCallArguments.clear();
                        structObjectMap.clear();
                        usingColumnsByStatement.clear();
                        scopeBuildResult = null;
                        try {
                                if(sqlenv!=null) {
                                        sqlparser.setSqlEnv(sqlenv);
                                }
                                int result = sqlparser.parse();
                                if (modelManager.getSqllrObservations() != null) {
                                        modelManager.getSqllrObservations().parsedUnit(sqlparser, result);
                                }
                                TSQLResolver2 parsedResolver = sqlparser.getResolver2();
                                scopeBuildResult = parsedResolver != null ? parsedResolver.getScopeBuildResult() : null;
                                if (collisionScanPending) {
                                        collisionScanPending = false;
                                        publishContestedNormalNames(NormalNameCollisions.scanTokens(collisionService(),
                                                        Collections.singletonList(sqlparser.sourcetokenlist)));
                                }
                if (commentBindingCollector != null) commentBindingCollector.capture(commentSourceKey, sqlparser, result != 0);
                                if (result != 0) {
                                        ArrayList<TSyntaxError> errors = sqlparser.getSyntaxErrors();
                                        if ((errors == null || errors.isEmpty())
                                                        && sqlparser.getErrormessage() != null
                                                        && !sqlparser.getErrormessage().isEmpty()) {
                                                // A refusal with no syntax errors -- the trial size cap
                                                // is the one that behaves this way. Recording nothing
                                                // here turned the rejection into an ordinary EMPTY
                                                // lineage result, which reads as "this SQL has no
                                                // dependencies" rather than "this SQL was not analyzed".
                                                ErrorInfo errorInfo = new ErrorInfo();
                                                errorInfo.setErrorType(ErrorInfo.SYNTAX_ERROR);
                                                errorInfo.setErrorMessage(sqlparser.getErrormessage());
                                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(1L, 1L,
                                                                ModelBindingManager.getGlobalHash()));
                                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(1L, 1L,
                                                                ModelBindingManager.getGlobalHash()));
                                                errorInfo.fillInfo(this);
                                                errorInfos.add(errorInfo);
                                        }
                                        if (errors != null && !errors.isEmpty()) {
                                                for (int i = 0; i < errors.size(); i++) {
                                                        TSyntaxError error = errors.get(i);
                                                        ErrorInfo errorInfo = syntaxErrorInfo(error, "");
                                                        errorInfos.add(errorInfo);
                                                }
                                        }
                                }
                                // Statements routine recovery skipped (Option.setRecoverRoutineBodyErrors): the routine parsed and is
                                // analyzed with the rest of its body, but each skipped statement is still a syntax error of this SQL.
                                for (TSyntaxError error : sqlparser.getRecoveredSyntaxErrors()) {
                                        errorInfos.add(syntaxErrorInfo(error,
                                                        " (" + skippedStatement(sqlparser, error) + " skipped, rest of the routine analyzed)"));
                                }
                                if (option.getHandleListener() != null) {
                                        option.getHandleListener().endParse(result == 0);
                                }
                        } catch (Exception e) {
                                logger.error("analyze sql failed.", e);
                                if (option.getHandleListener() != null) {
                                        option.getHandleListener().endParse(false);
                                }
                                ErrorInfo errorInfo = new ErrorInfo();
                                errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                                if (e.getMessage() == null) {
                                        if (e.getStackTrace() != null && e.getStackTrace().length > 0) {
                                                errorInfo
                                                                .setErrorMessage(e.getClass().getSimpleName() + ": " + e.getStackTrace()[0].toString());
                                        } else {
                                                errorInfo.setErrorMessage(e.getClass().getSimpleName());
                                        }
                                } else {
                                        errorInfo.setErrorMessage(e.getClass().getSimpleName() + ": " + e.getMessage());
                                }
                                errorInfo.fillInfo(this);
                                errorInfos.add(errorInfo);
                                return;
                        }

                        
                        TSQLResolver2 resolver = sqlparser.getResolver2();
                        if (resolver != null && option.getVendor() == EDbVendor.dbvbigquery) {
                                ScopeBuildResult buildResult = resolver.getScopeBuildResult();
                                List<TObjectName> columns = buildResult.getAllColumnReferences();
                                for (TObjectName col : columns) {
                                        structObjectMap.putIfAbsent(col.getSourceTable(), new TObjectNameList());
                                        structObjectMap.get(col.getSourceTable()).addObjectName(col);
                                }
                        }
                        
                        if (option.getHandleListener() != null) {
                                option.getHandleListener().startAnalyzeDataFlow(sqlparser);
                        }

                        ModelBindingManager.setSchemaUnsetStatements(collectSchemaUnsetStatements(sqlparser));
                        recordStatementOrdinals(sqlparser);

                        for (int i = 0; i < sqlparser.getSqlstatements().size(); i++) {
                                if (option.getHandleListener() != null && option.getHandleListener().isCanceled()) {
                                        break;
                                }

                                TCustomSqlStatement stmt = sqlparser.getSqlstatements().get(i);
                                if (stmt.getErrorCount() == 0) {
                                        if (stmt.getParentStmt() == null) {
                                                modelManager.collectSqlHash(stmt);
                                                if (stmt instanceof TUseDatabase || stmt instanceof TUseSchema
                                                                || stmt instanceof TCreateTableSqlStatement
                                                                || stmt instanceof TCreateExternalDataSourceStmt || stmt instanceof TCreateStageStmt
                                                                || stmt instanceof TMssqlCreateType
                                                                || stmt instanceof TMssqlDeclare
                                                                || stmt instanceof TPlsqlCreateType_Placeholder
                                                                || stmt instanceof TPlsqlCreateType
                                                                || stmt instanceof TPlsqlTableTypeDefStmt
                                                                || (stmt instanceof TCreateFunctionStmt && hasDb2ReturnStmt((TCreateFunctionStmt)stmt))
                                                                || (stmt instanceof TMssqlCreateFunction
                                                                                && (((TMssqlCreateFunction) stmt).getReturnTableDefinitions() != null
                                                                                                || ((TMssqlCreateFunction) stmt).getReturnStmt() != null))) {
                                                        boolean listen = false;
                                                        if (option.getHandleListener() != null && !accessedStatements.contains(stmt)) {
                                                                option.getHandleListener().startAnalyzeStatment(stmt);
                                                                listen = true;
                                                        }
                                                        analyzeCustomSqlStmt(stmt);
                                                        if (listen && option.getHandleListener() != null) {
                                                                option.getHandleListener().endAnalyzeStatment(stmt);
                                                        }
                                                }
                                        }
                                }
                        }

                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                if (option.getHandleListener() != null && option.getHandleListener().isCanceled()) {
                                        break;
                                }

                                TCustomSqlStatement stmt = sqlparser.getSqlstatements().get(i);
                                if (stmt.getErrorCount() == 0) {
                                        if (stmt.getParentStmt() == null) {
                                                if (stmt instanceof TUseDatabase 
                                                                || stmt instanceof TUseSchema
                                                                || stmt instanceof TCreateViewSqlStatement 
                                                                || stmt instanceof TCreateSynonymStmt 
                                                                || stmt instanceof TStoredProcedureSqlStatement) {
                                                        boolean listen = false;
                                                        if (option.getHandleListener() != null && !accessedStatements.contains(stmt)) {
                                                                option.getHandleListener().startAnalyzeStatment(stmt);
                                                                listen = true;
                                                        }
                                                        if (stmt instanceof TUseDatabase || stmt instanceof TUseSchema) {
                                                                analyzeCustomSqlStmt(stmt);
                                                        } else if (stmt instanceof TCreateViewSqlStatement) {
                                                                TCreateViewSqlStatement view = (TCreateViewSqlStatement) stmt;
                                                                if(view.getViewName()!=null) {
                                                                        viewDDLMap.put(DlineageUtil.getTableIdentityKey(view.getViewName().toString()), view);
                                                                }
                                                        } else if (stmt instanceof TCreateSynonymStmt) {
                                                                TCreateSynonymStmt synonym = (TCreateSynonymStmt) stmt;
                                                                if(synonym.getSynonymName()!=null) {
                                                                        viewDDLMap.put(DlineageUtil.getTableIdentityKey(synonym.getSynonymName().toString()), synonym);
                                                                }
                                                        } else if (stmt instanceof TStoredProcedureSqlStatement) {
                                                                TStoredProcedureSqlStatement procedure = (TStoredProcedureSqlStatement) stmt;
                                                                if(procedure.getStoredProcedureName() == null) {
                                                                        continue;
                                                                }
                                                                procedureDDLAliases.put(nameAliasKey(DlineageUtil.getProcedureOrFunctionName(procedure),
                                                                                RoutineAliases.argumentCount(procedure, ModelBindingManager.getGlobalVendor())), procedure);
                                                                if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) {
                                                                        gudusoft.gsqlparser.dlineage.routine.RoutineShadow.definition(modelManager, procedure);
                                                                }
                                                        }
                                                        if (listen && option.getHandleListener() != null) {
                                                                option.getHandleListener().endAnalyzeStatment(stmt);
                                                        }
                                                }
                                        }
                                }
                        }

                        // A view reading a table that an ALTER TABLE before it adds columns to, or reading such a view, and a synonym
                        // of such a view, is analyzed with the statements after the views, in script order: after the ALTER, so it
                        // reads the added columns, while the statements before the ALTER still see the table without them
                        // (Mantis 4846). A table is known by its name and by the catalog table TSQLResolver2 bound it to, so
                        // events and public.events are one table.
                        Set<TCustomSqlStatement> deferredViews = new LinkedHashSet<TCustomSqlStatement>();
                        Set<Object> alteredTables = new HashSet<Object>();
                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                if (option.getHandleListener() != null && option.getHandleListener().isCanceled()) {
                                        break;
                                }

                                TCustomSqlStatement stmt = sqlparser.getSqlstatements().get(i);
                                if (stmt.getErrorCount() == 0) {
                                        if (stmt.getParentStmt() == null) {
                                                if (stmt instanceof TAlterTableStatement && addsColumns((TAlterTableStatement) stmt)) {
                                                        TAlterTableStatement alter = (TAlterTableStatement) stmt;
                                                        alteredTables.add(DlineageUtil.getTableIdentityKey(alter.getTableName().toString()));
                                                        if (alter.getTargetTable() != null && alter.getTargetTable().getResolvedTable() != null) {
                                                                alteredTables.add(alter.getTargetTable().getResolvedTable());
                                                        }
                                                }
                                                if ((stmt instanceof TCreateViewSqlStatement || stmt instanceof TCreateSynonymStmt)
                                                                && !alteredTables.isEmpty() && readsAlteredTable(stmt, alteredTables)) {
                                                        deferredViews.add(stmt);
                                                        TObjectName name = deferredName(stmt);
                                                        if (name != null) {
                                                                alteredTables.add(DlineageUtil.getTableIdentityKey(name.toString()));
                                                        }
                                                        continue;
                                                }
                                                if (stmt instanceof TUseDatabase 
                                                                || stmt instanceof TUseSchema
                                                                || stmt instanceof TCreateViewSqlStatement 
                                                                || stmt instanceof TCreateSynonymStmt) {
                                                        boolean listen = false;
                                                        if (option.getHandleListener() != null && !accessedStatements.contains(stmt)) {
                                                                option.getHandleListener().startAnalyzeStatment(stmt);
                                                                listen = true;
                                                        }
                                                        analyzeCustomSqlStmt(stmt);
                                                        if (listen && option.getHandleListener() != null) {
                                                                option.getHandleListener().endAnalyzeStatment(stmt);
                                                        }
                                                }
                                        }
                                }
                        }

                        Set<TCustomSqlStatement> deferredRoutines = deferredRoutines(sqlparser, deferredViews);
                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                if (option.getHandleListener() != null && option.getHandleListener().isCanceled()) {
                                        break;
                                }

                                TCustomSqlStatement stmt = sqlparser.getSqlstatements().get(i);
                                if (stmt.getErrorCount() == 0) {
                                        if (stmt.getParentStmt() == null) {
                                                if (deferredRoutines.contains(stmt)) {
                                                        continue;
                                                }
                                                if (stmt instanceof TUseDatabase || stmt instanceof TUseSchema
                                                                || stmt instanceof TStoredProcedureSqlStatement) {
                                                        boolean listen = false;
                                                        if (option.getHandleListener() != null && !accessedStatements.contains(stmt)) {
                                                                option.getHandleListener().startAnalyzeStatment(stmt);
                                                                listen = true;
                                                        }
                                                        if (stmt instanceof TPlsqlCreateTrigger)
                                                                continue;
                                                        analyzeDeferredViewsReadBy(stmt, deferredViews);
                                                        analyzeCustomSqlStmt(stmt);
                                                        if (listen && option.getHandleListener() != null) {
                                                                option.getHandleListener().endAnalyzeStatment(stmt);
                                                        }
                                                }
                                        }
                                }
                        }

                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                if (option.getHandleListener() != null && option.getHandleListener().isCanceled()) {
                                        break;
                                }

                                TCustomSqlStatement stmt = sqlparser.getSqlstatements().get(i);

                                if (option.isIgnoreTopSelect()) {
                                        if ((stmt instanceof TSelectSqlStatement && ((TSelectSqlStatement)stmt).getIntoClause() == null && ((TSelectSqlStatement)stmt).getIntoTableClause() == null ) || stmt instanceof TRedshiftDeclare
                                                        || stmt instanceof TRedshiftDeclare) {
                                                continue;
                                        }
                                }

                                if (stmt.getErrorCount() == 0) {
                                        if (stmt.getParentStmt() == null) {
                                                if ((!(stmt instanceof TCreateViewSqlStatement) || deferredViews.contains(stmt))
                                                                && !(stmt instanceof TCreateStageStmt)
                                                                && !(stmt instanceof TCreateExternalDataSourceStmt)
                                                                && !(stmt instanceof TMssqlDeclare)
                                                                && !(stmt instanceof TMssqlCreateFunction
                                                                                && ((TMssqlCreateFunction) stmt).getReturnTableDefinitions() != null)) {
                                                        boolean listen = false;
                                                        if (option.getHandleListener() != null && !accessedStatements.contains(stmt)) {
                                                                option.getHandleListener().startAnalyzeStatment(stmt);
                                                                listen = true;
                                                        }
                                                        analyzeDeferredViewsReadBy(stmt, deferredViews);
                                                        analyzeCustomSqlStmt(stmt);
                                                        if (listen && option.getHandleListener() != null) {
                                                                option.getHandleListener().endAnalyzeStatment(stmt);
                                                        }
                                                }
                                        }
                                }
                        }

                        if (option.getHandleListener() != null) {
                                option.getHandleListener().endAnalyzeDataFlow(sqlparser);
                        }

                        // Finalize pipelined function stitching after all passes
                        if (!modelManager.getPendingPipelinedCallSites().isEmpty() && sqlparser.getSqlstatements().size() > 0 && pipelinedAnalyzer != null) {
                                TCustomSqlStatement lastStmt = sqlparser.getSqlstatements().get(sqlparser.getSqlstatements().size() - 1);
                                stmtStack.push(lastStmt);
                                // This statement is a stand-in for a non-empty stack, not the call site these
                                // relationships came from; say so, so nothing reads provenance off it.
                                ModelBindingManager.setSyntheticStmtContext(true);
                                try {
                                        pipelinedAnalyzer.stitchPendingCallSites();
                                } catch (Exception ex) {
                                        // Don't let pipelined stitching failure break main flow
                                } finally {
                                        ModelBindingManager.setSyntheticStmtContext(false);
                                        stmtStack.pop();
                                }
                        }
                } catch (Throwable e) {
                        if (e instanceof java.lang.Error && sqllrProducerMode()) {
                                throw (java.lang.Error) e; // SQL-LR production never turns an Error into a partial document
                        }
                        logger.error("analyze sql failed.", e);
                        ErrorInfo errorInfo = new ErrorInfo();
                        errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                        if (e.getMessage() == null) {
                                if (e.getStackTrace() != null && e.getStackTrace().length > 0) {
                                        errorInfo.setErrorMessage(e.getClass().getSimpleName() + ": " + e.getStackTrace()[0].toString());
                                } else {
                                        errorInfo.setErrorMessage(e.getClass().getSimpleName());
                                }
                        } else {
                                errorInfo.setErrorMessage(e.getClass().getSimpleName() + ": " + e.getMessage());
                        }
                        errorInfo.fillInfo(this);
                        errorInfos.add(errorInfo);
                }

        }

        private static boolean containsSame(List<TableColumn> columns, TableColumn column) {
                for (TableColumn c : columns) {
                        if (c == column) {
                                return true;
                        }
                }
                return false;
        }

        /**
         * The routines analyzed with the statements after the routines, in script order (Mantis 4883), as such a view is
         * (Mantis 4846): behind an ALTER TABLE that adds columns, a routine reading the altered table, a view deferred for
         * it, or a table a deferred routine makes or fills (a later reader would see it without columns), and a routine
         * calling a deferred one, whose call would otherwise analyze it before the ALTER.
         */
        private Set<TCustomSqlStatement> deferredRoutines(TGSqlParser sqlparser, Set<TCustomSqlStatement> deferredViews) {
                Set<TCustomSqlStatement> deferred = new LinkedHashSet<TCustomSqlStatement>();
                Map<TCustomSqlStatement, Set<Object>> read = new IdentityHashMap<TCustomSqlStatement, Set<Object>>();
                Map<TCustomSqlStatement, Set<Object>> called = new IdentityHashMap<TCustomSqlStatement, Set<Object>>();
                Map<TCustomSqlStatement, Set<Object>> made = new IdentityHashMap<TCustomSqlStatement, Set<Object>>();
                for (boolean changed = true; changed;) {
                        changed = false;
                        Set<Object> deferredNames = new HashSet<Object>();
                        for (TCustomSqlStatement routine : deferred) {
                                addRoutineKey(deferredNames, DlineageUtil.getProcedureOrFunctionName((TStoredProcedureSqlStatement) routine));
                        }
                        Set<Object> altered = new HashSet<Object>();
                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                TCustomSqlStatement stmt = sqlparser.getSqlstatements().get(i);
                                if (stmt.getErrorCount() != 0 || stmt.getParentStmt() != null) {
                                        continue;
                                }
                                if (!(stmt instanceof TStoredProcedureSqlStatement)) {
                                        addAlteredTables(altered, stmt);
                                        if (deferredViews.contains(stmt) && deferredName(stmt) != null) {
                                                altered.add(DlineageUtil.getTableIdentityKey(deferredName(stmt).toString()));
                                        }
                                } else if (!(stmt instanceof TPlsqlCreateTrigger) && !altered.isEmpty()) {
                                        if (!read.containsKey(stmt)) {
                                                read.put(stmt, tablesRead(stmt));
                                                called.put(stmt, routinesCalled(stmt));
                                        }
                                        if (!deferred.contains(stmt) && (!Collections.disjoint(read.get(stmt), altered)
                                                        || !Collections.disjoint(called.get(stmt), deferredNames))) {
                                                deferred.add(stmt);
                                                changed = true;
                                        }
                                        if (deferred.contains(stmt)) {
                                                if (!made.containsKey(stmt)) {
                                                        made.put(stmt, tablesMade(stmt));
                                                }
                                                altered.addAll(made.get(stmt));
                                        }
                                }
                        }
                }
                return deferred;
        }

        /** Adds the tables an ALTER TABLE adding columns changes, {@code stmt} itself or one in its block, to {@code altered}. */
        private static void addAlteredTables(final Set<Object> altered, TCustomSqlStatement stmt) {
                List<TAlterTableStatement> alters = new ArrayList<TAlterTableStatement>();
                if (stmt instanceof TAlterTableStatement) {
                        alters.add((TAlterTableStatement) stmt);
                } else if (stmt.getStatements() != null && stmt.getStatements().size() > 0) {
                        // a block: BEGIN ALTER TABLE ... END
                        final List<TAlterTableStatement> nested = alters;
                        stmt.acceptChildren(new TParseTreeVisitor() {
                                @Override
                                public void preVisit(TAlterTableStatement alter) {
                                        nested.add(alter);
                                }
                        });
                }
                for (TAlterTableStatement alter : alters) {
                        if (addsColumns(alter)) {
                                altered.add(DlineageUtil.getTableIdentityKey(alter.getTableName().toString()));
                                if (alter.getTargetTable() != null && alter.getTargetTable().getResolvedTable() != null) {
                                        altered.add(alter.getTargetTable().getResolvedTable());
                                }
                        }
                }
        }

        /** The tables {@code stmt} makes: SELECT ... INTO targets and CREATE TABLE tables, by identity key. */
        private static Set<Object> tablesMade(TCustomSqlStatement stmt) {
                final Set<Object> keys = new HashSet<Object>();
                stmt.acceptChildren(new TParseTreeVisitor() {
                        @Override
                        public void preVisit(TSelectSqlStatement select) {
                                TIntoClause into = select.getIntoClause();
                                if (into != null && into.getIntoName() != null) {
                                        keys.add(DlineageUtil.getTableIdentityKey(into.getIntoName().toString()));
                                }
                                if (into != null && into.getExprList() != null) {
                                        for (int i = 0; i < into.getExprList().size(); i++) {
                                                keys.add(DlineageUtil.getTableIdentityKey(into.getExprList().getExpression(i).toString()));
                                        }
                                }
                        }

                        @Override
                        public void preVisit(TCreateTableSqlStatement create) {
                                if (create.getTargetTable() != null && create.getTargetTable().getTableName() != null) {
                                        keys.add(DlineageUtil.getTableIdentityKey(create.getTargetTable().getTableName().toString()));
                                }
                        }
                });
                return keys;
        }

        /** The routines {@code stmt} calls, by {@link #addRoutineKey}: EXEC, INSERT ... EXEC, CALL and function calls. */
        private Set<Object> routinesCalled(TCustomSqlStatement stmt) {
                final Set<Object> keys = new HashSet<Object>();
                stmt.acceptChildren(new TParseTreeVisitor() {
                        @Override
                        public void preVisit(TMssqlExecute execute) {
                                addRoutineKey(keys, execute.getModuleName());
                        }

                        @Override
                        public void preVisit(TInsertSqlStatement insert) {
                                // acceptChildren does not visit the EXEC of INSERT ... EXEC
                                if (insert.getExecuteStmt() != null) {
                                        addRoutineKey(keys, insert.getExecuteStmt().getModuleName());
                                }
                        }

                        @Override
                        public void preVisit(TCallStatement call) {
                                // nor the routine of CALL
                                addRoutineKey(keys, call.getRoutineName());
                                if (call.getRoutineExpr() != null && call.getRoutineExpr().getFunctionCall() != null) {
                                        addRoutineKey(keys, call.getRoutineExpr().getFunctionCall().getFunctionName());
                                }
                        }

                        @Override
                        public void preVisit(TFunctionCall call) {
                                addRoutineKey(keys, call.getFunctionName());
                        }
                });
                return keys;
        }

        /**
         * The routine identity key of the last part of {@code name}, which an unqualified call names a routine by; a schema
         * the call does not write is not compared, so a call can only defer one routine too many.
         */
        private void addRoutineKey(Set<Object> keys, TObjectName name) {
                if (name != null && name.getObjectString() != null) {
                        keys.add(SQLUtil.canonKey(option.getVendor(), ESQLDataObjectType.dotFunction, name.getObjectString()));
                }
        }

        /** Whether {@code alter} adds a column: ADD COLUMN, ADD COLUMNS, ADD COLUMN IF NOT EXISTS. */
        private static boolean addsColumns(TAlterTableStatement alter) {
                if (alter.getTableName() == null || alter.getAlterTableOptionList() == null) {
                        return false;
                }
                for (int i = 0; i < alter.getAlterTableOptionList().size(); i++) {
                        EAlterTableOptionType type = alter.getAlterTableOptionList().getAlterTableOption(i).getOptionType();
                        if (type == EAlterTableOptionType.AddColumn || type == EAlterTableOptionType.addColumnIfNotExists) {
                                return true;
                        }
                }
                return false;
        }

        /**
         * The tables {@code stmt} reads, anywhere in it: the identity key of each name and the catalog table TSQLResolver2
         * bound it to.
         */
        private static Set<Object> tablesRead(TCustomSqlStatement stmt) {
                final Set<Object> keys = new HashSet<Object>();
                stmt.acceptChildren(new TParseTreeVisitor() {
                        @Override
                        public void preVisit(TTable table) {
                                if (table.getTableName() != null) {
                                        keys.add(DlineageUtil.getTableIdentityKey(table.getTableName().toString()));
                                }
                                if (table.getResolvedTable() != null) {
                                        keys.add(table.getResolvedTable());
                                }
                        }
                });
                return keys;
        }

        /** Whether the view {@code stmt} reads, or the synonym {@code stmt} names, a table of {@code alteredTables}. */
        private static boolean readsAlteredTable(TCustomSqlStatement stmt, Set<Object> alteredTables) {
                if (stmt instanceof TCreateSynonymStmt) {
                        TObjectName forName = ((TCreateSynonymStmt) stmt).getForName();
                        return forName != null && alteredTables.contains(DlineageUtil.getTableIdentityKey(forName.toString()));
                }
                return !Collections.disjoint(tablesRead(stmt), alteredTables);
        }

        /** The name a deferred view or synonym defines. */
        private static TObjectName deferredName(TCustomSqlStatement stmt) {
                if (stmt instanceof TCreateViewSqlStatement) {
                        return ((TCreateViewSqlStatement) stmt).getViewName();
                }
                if (stmt instanceof TCreateSynonymStmt) {
                        return ((TCreateSynonymStmt) stmt).getSynonymName();
                }
                return null;
        }

        /**
         * Analyzes, before {@code stmt}, each view of {@code deferredViews} that {@code stmt} reads and that is not analyzed
         * yet: a view is analyzed before a statement that reads it, as when it is not deferred (Mantis 4846).
         */
        private void analyzeDeferredViewsReadBy(TCustomSqlStatement stmt, Set<TCustomSqlStatement> deferredViews) {
                if (deferredViews.isEmpty() || deferredViews.contains(stmt) || accessedStatements.contains(stmt)) {
                        return;
                }
                Set<Object> read = null;
                for (TCustomSqlStatement view : deferredViews) {
                        TObjectName viewName = deferredName(view);
                        if (accessedStatements.contains(view) || viewName == null) {
                                continue;
                        }
                        if (read == null) {
                                read = tablesRead(stmt);
                        }
                        if (read.contains(DlineageUtil.getTableIdentityKey(viewName.toString()))) {
                                analyzeCustomSqlStmt(view);
                        }
                }
        }

        private boolean hasDb2ReturnStmt(TCreateFunctionStmt stmt) {
                if (stmt.getReturnStmt() != null) {
                        return true;
                }
                if (stmt.getBodyStatements() != null) {
                        for (int i = 0; i < stmt.getBodyStatements().size(); i++) {
                                if(stmt.getBodyStatements().get(i) instanceof TDb2ReturnStmt) {
                                        return true;
                                }
                        }
                }
                return false;
        }


        /**
         * The statements that a Snowflake {@code USE <database>} left with no current
         * schema: everything after such a switch, up to the next schema switch.
         *
         * <p>Computed once, in statement order, because the analysis below walks the
         * list several times and replays the {@code USE} statements in every pass. A
         * running flag would still be set when a later pass reached a statement that
         * PRECEDES the switch, and would strip that statement's already-exact
         * qualification. Keyed by statement, the answer does not depend on the pass.
         *
         * <p>Only Snowflake can populate this, so no other vendor's output moves.
         * See GitHub #715 / MantisBT 4677.
         */
        private Set<TCustomSqlStatement> collectSchemaUnsetStatements(TGSqlParser sqlparser) {
                Set<TCustomSqlStatement> unset = new HashSet<TCustomSqlStatement>();
                if (sqlparser == null || sqlparser.getSqlstatements() == null) {
                        return unset;
                }
                boolean schemaUnset = false;
                for (int i = 0; i < sqlparser.getSqlstatements().size(); i++) {
                        TCustomSqlStatement stmt = sqlparser.getSqlstatements().get(i);
                        if (stmt == null) {
                                continue;
                        }
                        if (schemaUnset) {
                                unset.add(stmt);
                        }
                        if (stmt.dbvendor != EDbVendor.dbvsnowflake) {
                                continue;
                        }
                        if (stmt instanceof TUseSchema || stmt.sqlstatementtype == ESqlStatementType.sstSetSchema) {
                                schemaUnset = false;
                        } else if (stmt instanceof TUseDatabase) {
                                schemaUnset = !((TUseDatabase) stmt).isSchema();
                        }
                }
                return unset;
        }

        private int parseWithCommentBindings(TGSqlParser parser) {
        int result = parser.parse();
        if (commentBindingCollector != null) commentBindingCollector.captureDerived(parser, result != 0);
        return result;
    }

    private void analyzeCustomSqlStmt(TCustomSqlStatement stmt) {
                analysisPath.add(stmt);
                Long ordinal = stmt == null ? null : statementOrdinals.get(stmt);
                long previousOrdinal = modelManager.getCurrentStatementOrdinal();
                if (ordinal != null) {
                        modelManager.setCurrentStatementOrdinal(ordinal);
                }
                SqllrObservations sqllr = modelManager.getSqllrObservations();
                boolean sqllrTop = sqllr != null && stmtStack.isEmpty();
                int sqllrDepth = stmtStack.size();
                Throwable sqllrFailure = null;
                if (sqllr != null) {
                        // every statement the analysis enters, so its place on the stack is known even when it records nothing
                        sqllr.enterStatement(stmt);
                }
                try {
                        if (sqllr != null && dynamicFoldDepth > 0) {
                                // a statement of dynamic SQL text: the statement before it on the path parsed it (SQL-LR derived units)
                                sqllr.derivedStatement(stmt, analysisPath.size() > 1 ? analysisPath.get(analysisPath.size() - 2)
                                                : null);
                        }
                        if (sqllrTop) {
                                sqllr.beginStatement(stmt);
                        }
                        analyzeCustomSqlStmtOnPath(stmt);
                        analyzeUnreadDataChangingCtes(stmt);
                        if (sqllrTop) {
                                sqllr.checkInjectedFailure(stmt, false);
                        }
                } catch (RuntimeException e) {
                        sqllrFailure = e;
                        if (!sqllrTop || !sqllr.isProducerMode()) {
                                throw e;
                        }
                        // SQL-LR production isolates a failed top-level statement: the statement is reported FAILED and its
                        // partial relationships are not published; the statements after it are still analyzed. Every other run
                        // (no recorder, or an observe-only one) keeps failing as before.
                        while (stmtStack.size() > sqllrDepth) {
                                stmtStack.pop();
                        }
                } catch (java.lang.Error e) {
                        sqllrFailure = e;
                        throw e;
                } finally {
                        if (sqllrTop) {
                                sqllr.endStatement(stmt, sqllrFailure);
                        }
                        modelManager.setCurrentStatementOrdinal(previousOrdinal);
                        analysisPath.remove(analysisPath.size() - 1);
                }
        }

        /**
         * A data-changing statement in a CTE runs whether or not the statement reads the CTE (PostgreSQL executes every
         * data-modifying statement in WITH exactly once): its body is analyzed where a FROM item reads the CTE, and here,
         * after the statement, when nothing did, so the writes of {@code WITH x AS (INSERT INTO t SELECT a FROM s)
         * SELECT 1} are not lost (plan 09). The statement stays on the stack: the body is part of it, never a statement of
         * its own.
         */
        private void analyzeUnreadDataChangingCtes(TCustomSqlStatement stmt) {
                if (stmt == null || stmt.getCteList() == null) {
                        return;
                }
                for (int i = 0; i < stmt.getCteList().size(); i++) {
                        TCTE cte = stmt.getCteList().getCTE(i);
                        if (cte == null || cte.getSubquery() != null) {
                                continue;
                        }
                        TCustomSqlStatement body = cte.getUpdateStmt() != null ? cte.getUpdateStmt()
                                        : cte.getInsertStmt() != null ? cte.getInsertStmt()
                                        : cte.getDeleteStmt() != null ? cte.getDeleteStmt() : cte.getMergeStmt();
                        if (body == null || accessedStatements.contains(body)) {
                                continue;
                        }
                        stmtStack.push(stmt);
                        try {
                                analyzeCustomSqlStmt(body);
                        } finally {
                                stmtStack.pop();
                        }
                }
        }

        /**
         * Plan rule R10: the position of each top-level statement in the script, the unit first and the statement in
         * the unit second, so a read is validated against the CREATE TABLE in force where it stands even though every
         * CREATE TABLE of a unit is analyzed before its other statements.
         */
        private final Map<TCustomSqlStatement, Long> statementOrdinals = new IdentityHashMap<TCustomSqlStatement, Long>();

        /**
         * Plan rule R10: the lifetime of each top-level CREATE TABLE's declaration, found by pairing the script's CREATE
         * and DROP TABLE statements per table name as a stack, in script order: a DROP ends the declaration on top (a
         * temporary table's, which shadows a permanent one of its name, before the permanent one); a CREATE ... IF NOT
         * EXISTS of a table that exists declares nothing; a plain CREATE of a permanent table that exists replaces it.
         */
        private final Map<Object, Deque<long[]>> declarationStacks = new HashMap<Object, Deque<long[]>>();

        /** The ordinal at which each CREATE TABLE's declaration ends, by the CREATE's ordinal. */
        private final Map<Long, Long> declarationEnds = new HashMap<Long, Long>();

        /** The CREATE TABLE ... IF NOT EXISTS statements whose table already existed: they declare nothing. */
        private final Set<Long> noOpCreates = new HashSet<Long>();

        /** How many units have been analyzed: the first part of a statement ordinal. */
        private long analyzedUnits = 0;

        private static final long STATEMENTS_PER_UNIT = 1L << 32;

        private void recordStatementOrdinals(TGSqlParser sqlparser) {
                long unit = analyzedUnits++;
                unitParser = sqlparser;
                unitTableNames = null;
                for (int i = 0; i < sqlparser.getSqlstatements().size(); i++) {
                        TCustomSqlStatement stmt = sqlparser.getSqlstatements().get(i);
                        long ordinal = unit * STATEMENTS_PER_UNIT + i;
                        statementOrdinals.put(stmt, ordinal);
                        if (stmt instanceof TCreateTableSqlStatement && ((TCreateTableSqlStatement) stmt).getTargetTable() != null
                                        && ((TCreateTableSqlStatement) stmt).getTargetTable().getTableName() != null) {
                                TCreateTableSqlStatement create = (TCreateTableSqlStatement) stmt;
                                Deque<long[]> stack = declarationStack(create.getTargetTable().getTableName().toString());
                                boolean temporary = isTemporaryTable(create);
                                if (create.isIfNotExists() && !stack.isEmpty()) {
                                        noOpCreates.add(ordinal);
                                } else {
                                        if (!temporary && !stack.isEmpty() && stack.peek()[1] == 0) {
                                                // a permanent table created again replaces the one it names
                                                declarationEnds.put(stack.pop()[0], ordinal);
                                        }
                                        stack.push(new long[]{ordinal, temporary ? 1 : 0});
                                }
                        } else if (stmt instanceof TDropTableSqlStatement && ((TDropTableSqlStatement) stmt).getTargetTable() != null
                                        && ((TDropTableSqlStatement) stmt).getTargetTable().getTableName() != null) {
                                Deque<long[]> stack = declarationStack(
                                                ((TDropTableSqlStatement) stmt).getTargetTable().getTableName().toString());
                                if (!stack.isEmpty()) {
                                        declarationEnds.put(stack.pop()[0], ordinal);
                                }
                        }
                }
        }

        private Deque<long[]> declarationStack(String tableName) {
                Object key = DlineageUtil.getTableIdentityKey(tableName);
                Deque<long[]> stack = declarationStacks.get(key);
                if (stack == null) {
                        stack = new ArrayDeque<long[]>();
                        declarationStacks.put(key, stack);
                }
                return stack;
        }

        private static boolean isTemporaryTable(TCreateTableSqlStatement create) {
                EnumSet<ETableKind> kinds = create.getTableKinds();
                if (kinds == null) {
                        return false;
                }
                for (ETableKind kind : kinds) {
                        switch (kind) {
                        case etkTemporary:
                        case etkGlobalTemporary:
                        case etkLocalTemporary:
                        case etkTemp:
                        case etkGlobalTemp:
                        case etkLocalTemp:
                        case etkVolatile:
                        case etkLocalVolatile:
                        case etkGlobalVolatile:
                        case etkPrivateTemporary:
                        case etkScopedTemporary:
                                return true;
                        default:
                                break;
                        }
                }
                return false;
        }

        /** The ordinal at which the declaration of the CREATE TABLE {@code created} ends, else NEVER_DROPPED. */
        private long declarationEnd(long created) {
                Long end = created < 0 ? null : declarationEnds.get(created);
                return end != null ? end : gudusoft.gsqlparser.dlineage.dataflow.model.FieldDeclaration.NEVER_DROPPED;
        }

    private void analyzeCustomSqlStmtOnPath(TCustomSqlStatement stmt) {
                if (stmt != null && dynamicFoldDepth == 0 && anyDynamicTemplateMarked) {
                        // A STATIC statement analyzed after a fold marked something: its references
                        // withdraw marks on shared nodes (see the field javadoc).
                        applyStaticTemplateVetoes(stmt);
                }
                if (!accessedStatements.contains(stmt)) {
                        accessedStatements.add(stmt);
                } else if (!(stmt instanceof TUseDatabase || stmt instanceof TUseSchema)) {
                        return;
                }

                ArrayList<TSyntaxError> errors = stmt.getSyntaxHints();
                if (errors != null && !errors.isEmpty()) {
                        for (int i = 0; i < errors.size(); i++) {
                                TSyntaxError error = errors.get(i);
                                ErrorInfo errorInfo = new ErrorInfo();
                                errorInfo.setErrorType(ErrorInfo.SYNTAX_HINT);
                                errorInfo.setErrorMessage(getErrorMessage(error, ErrorInfo.SYNTAX_HINT));
                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(error.lineNo, error.columnNo,
                                                ModelBindingManager.getGlobalHash()));
                                String[] segments = error.tokentext.split("\n");
                                if (segments.length == 1) {
                                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(error.lineNo,
                                                        error.columnNo + error.tokentext.length(), ModelBindingManager.getGlobalHash()));
                                } else {
                                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(error.lineNo + segments.length - 1,
                                                        (long) segments[segments.length - 1].length() + 1, ModelBindingManager.getGlobalHash()));
                                }
                                errorInfo.fillInfo(this);
                                errorInfos.add(errorInfo);
                        }
                }

                if (option.getAnalyzeMode() == AnalyzeMode.dynamic) {
                        if (!(stmt instanceof TStoredProcedureSqlStatement
                                        || stmt instanceof TExecuteSqlStatement
                                        || stmt instanceof TMssqlExecute
                                        || stmt instanceof TExecImmeStmt)) {
                                return;
                        }
                }

                if(DlineageUtil.getTopStmt(stmt) == stmt){
                        modelManager.collectSqlHash(stmt);
                }

                try {
                        if (stmt instanceof TUseDatabase) {
                                if (((TUseDatabase) stmt).getDatabaseName() != null) {
                                        // Snowflake: a database switch invalidates the schema carried
                                        // over from the PREVIOUS database. Leaving it attached makes
                                        // later unqualified names resolve as <newdb>.<oldschema>, a
                                        // pair that need not exist. Clear rather than assign PUBLIC:
                                        // that the old schema is invalid is provable from the
                                        // statement, that PUBLIC exists in the new database is not.
                                        // Matches TDDLSQLEnv.analyzeUseDatabase and
                                        // DatabaseContextTracker.processUseDatabase. See GitHub #715.
                                        //
                                        // The clearing happens HERE, in the statement-by-statement
                                        // analysis, and NOT in TUseDatabase.doParseStatement: the whole
                                        // batch is parsed before any of it is analyzed and one TSQLEnv
                                        // is shared across it, so a parse-time clear would also apply
                                        // to the statements BEFORE the switch and would downgrade their
                                        // already-exact names to unqualified ones. The env fallback is
                                        // handled per statement instead - see
                                        // ModelBindingManager.setSchemaUnsetStatements.
                                        if (stmt.dbvendor == EDbVendor.dbvsnowflake
                                                        && !((TUseDatabase) stmt).isSchema()) {
                                                ModelBindingManager.removeGlobalSchema();
                                        }
                                        ModelBindingManager.setGlobalDatabase(((TUseDatabase) stmt).getDatabaseName().toString());
                                }
                        } else if (stmt instanceof TUseSchema) {
                                if (((TUseSchema) stmt).getSchemaName() != null) {
                                        String schemaName = ((TUseSchema) stmt).getSchemaName().toString();
                                        List<String> splits = SQLUtil.parseNames(schemaName);
                                        if (splits.size() == 1) {
                                                ModelBindingManager.setGlobalSchema(schemaName);
                                        } else if (splits.size() > 1) {
                                                ModelBindingManager.setGlobalSchema(splits.get(splits.size() - 1));
                                                ModelBindingManager.setGlobalDatabase(splits.get(splits.size() - 2));
                                        }
                                }
                        } else if (stmt instanceof TPlsqlRecordTypeDefStmt) {
                                this.stmtStack.push(stmt);
                                this.analyzePlsqlRecordTypeDefStmt((TPlsqlRecordTypeDefStmt) stmt);
                                this.stmtStack.pop();
                        } else if (stmt instanceof TPlsqlCreateType_Placeholder) {
                                this.stmtStack.push(stmt);
                                TPlsqlCreateType_Placeholder placeholder = (TPlsqlCreateType_Placeholder) stmt;
                                if (placeholder.getObjectStatement() != null && pipelinedAnalyzer != null) {
                                        this.pipelinedAnalyzer.indexObjectType(placeholder.getObjectStatement());
                                }
                                if (placeholder.getNestedTableStatement() != null) {
                                        if (pipelinedAnalyzer != null) {
                                                this.pipelinedAnalyzer.indexCollectionType(placeholder.getNestedTableStatement());
                                        }
                                        this.analyzePlsqlTableTypeDefStmt(placeholder.getNestedTableStatement());
                                }
                                this.stmtStack.pop();
                        } else if (stmt instanceof TPlsqlCreateType) {
                                this.stmtStack.push(stmt);
                                if (pipelinedAnalyzer != null) {
                                        this.pipelinedAnalyzer.indexObjectType((TPlsqlCreateType) stmt);
                                }
                                this.stmtStack.pop();
                        } else if (stmt instanceof TPlsqlTableTypeDefStmt) {
                                this.stmtStack.push(stmt);
                                this.analyzePlsqlTableTypeDefStmt((TPlsqlTableTypeDefStmt) stmt);
                                if (pipelinedAnalyzer != null) {
                                        this.pipelinedAnalyzer.indexCollectionType((TPlsqlTableTypeDefStmt) stmt);
                                }
                                this.stmtStack.pop();
                        } else if (stmt instanceof TStoredProcedureSqlStatement) {
                                this.stmtStack.push(stmt);
                                this.analyzeStoredProcedureStmt((TStoredProcedureSqlStatement) stmt);
                                this.stmtStack.pop();
                        } else if (stmt instanceof TCreateTableSqlStatement) {
                                stmtStack.push(stmt);
                                analyzeCreateTableStmt((TCreateTableSqlStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TCreateStageStmt) {
                                stmtStack.push(stmt);
                                analyzeCreateStageStmt((TCreateStageStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TCreateExternalDataSourceStmt) {
                                stmtStack.push(stmt);
                                analyzeCreateExternalDataSourceStmt((TCreateExternalDataSourceStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TCreateStreamStmt) {
                                stmtStack.push(stmt);
                                analyzeCreateStreamStmt((TCreateStreamStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TSelectSqlStatement) {
                                analyzeSelectStmt((TSelectSqlStatement) stmt);
                        } else if (stmt instanceof TDropTableSqlStatement) {
                                stmtStack.push(stmt);
                                analyzeDropTableStmt((TDropTableSqlStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TTruncateStatement) {
                                stmtStack.push(stmt);
                                analyzeTruncateTableStmt((TTruncateStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TCreateMaterializedSqlStatement) {
                                stmtStack.push(stmt);
                                TCreateMaterializedSqlStatement view = (TCreateMaterializedSqlStatement) stmt;
                                analyzeCreateViewStmt(view, view.getSubquery(), view.getViewAliasClause(), view.getViewName());
                                stmtStack.pop();
                        } else if (stmt instanceof TCreateViewSqlStatement) {
                                stmtStack.push(stmt);
                                TCreateViewSqlStatement view = (TCreateViewSqlStatement) stmt;
                                analyzeCreateViewStmt(view, view.getSubquery(), view.getViewAliasClause(), view.getViewName());
                                stmtStack.pop();
                        } else if(stmt instanceof TDb2SqlVariableDeclaration){
                                stmtStack.push(stmt);
                                analyzeDb2Declare((TDb2SqlVariableDeclaration)stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TMssqlCreateType) {
                                stmtStack.push(stmt);
                                TMssqlCreateType createType = (TMssqlCreateType) stmt;
                                analyzeMssqlCreateType(createType);
                                stmtStack.pop();
                        } else if (stmt instanceof TMssqlDeclare) {
                                stmtStack.push(stmt);
                                TMssqlDeclare declare = (TMssqlDeclare) stmt;
                                analyzeMssqlDeclare(declare);
                                stmtStack.pop();
                        } else if (stmt instanceof TInsertSqlStatement) {
                                stmtStack.push(stmt);
                                TInsertSqlStatement insert = (TInsertSqlStatement)stmt;
                                analyzeInsertStmt(insert);
                                if(insert.getMultiInsertStatements()!=null) {
                                        for(int i=0;i<insert.getMultiInsertStatements().size();i++) {
                                                analyzeInsertStmt(insert.getMultiInsertStatements().get(i));
                                        }
                                }
                                stmtStack.pop();
                        } else if (stmt instanceof TRedshiftCopy) {
                                stmtStack.push(stmt);
                                analyzeRedshiftCopyStmt((TRedshiftCopy) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TMssqlBulkInsert) {
                                stmtStack.push(stmt);
                                analyzeMssqlBulkInsertStmt((TMssqlBulkInsert) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TSnowflakeCopyIntoStmt) {
                                stmtStack.push(stmt);
                                analyzeCopyIntoStmt((TSnowflakeCopyIntoStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TUnloadStmt) {
                                stmtStack.push(stmt);
                                analyzeUnloadStmt((TUnloadStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TUpdateSqlStatement) {
                                stmtStack.push(stmt);
                                analyzeUpdateStmt((TUpdateSqlStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TMergeSqlStatement) {
                                stmtStack.push(stmt);
                                analyzeMergeStmt((TMergeSqlStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TDeleteSqlStatement) {
                                stmtStack.push(stmt);
                                analyzeDeleteStmt((TDeleteSqlStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TCursorDeclStmt) {
                                stmtStack.push(stmt);
                                analyzeCursorDeclStmt((TCursorDeclStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TFetchStmt) {
                                stmtStack.push(stmt);
                                analyzeFetchStmt((TFetchStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TMssqlFetch) {
                                stmtStack.push(stmt);
                                analyzeFetchStmt((TMssqlFetch) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TForStmt) {
                                stmtStack.push(stmt);
                                analyzeForStmt((TForStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TOpenforStmt) {
                                stmtStack.push(stmt);
                                analyzeOpenForStmt((TOpenforStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TLoopStmt) {
                                stmtStack.push(stmt);
                                analyzeLoopStmt((TLoopStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TAssignStmt) {
                                stmtStack.push(stmt);
                                analyzeAssignStmt((TAssignStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TSetStmt) {
                                stmtStack.push(stmt);
                                analyzeSetStmt((TSetStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TMssqlSet) {
                                stmtStack.push(stmt);
                                analyzeMssqlSetStmt((TMssqlSet) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TVarDeclStmt) {
                                stmtStack.push(stmt);
                                analyzeVarDeclStmt((TVarDeclStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TCreateDatabaseSqlStatement) {
                                stmtStack.push(stmt);
                                analyzeCloneDatabaseStmt((TCreateDatabaseSqlStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TCreateSchemaSqlStatement) {
                                stmtStack.push(stmt);
                                analyzeCloneSchemaStmt((TCreateSchemaSqlStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TAlterTableStatement) {
                                stmtStack.push(stmt);
                                analyzeAlterTableStmt((TAlterTableStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TAlterViewStatement) {
                                stmtStack.push(stmt);
                                analyzeAlterViewStmt((TAlterViewStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TRenameStmt) {
                                stmtStack.push(stmt);
                                analyzeRenameStmt((TRenameStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TCreateSynonymStmt) {
                                stmtStack.push(stmt);
                                analyzeCreateSynonymStmt((TCreateSynonymStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TLoadDataStmt) {
                                stmtStack.push(stmt);
                                analyzeLoadDataStmt((TLoadDataStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof THiveLoad) {
                                stmtStack.push(stmt);
                                analyzeHiveLoadStmt((THiveLoad) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TDb2ReturnStmt) {
                                stmtStack.push(stmt);
                                analyzeDb2ReturnStmt((TDb2ReturnStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TReturnStmt) {
                                stmtStack.push(stmt);
                                analyzeReturnStmt((TReturnStmt) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TMssqlReturn) {
                                stmtStack.push(stmt);
                                analyzeMssqlReturnStmt((TMssqlReturn) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TMssqlUpdateText) {
                                stmtStack.push(stmt);
                                analyzeMssqlUpdateTextStmt((TMssqlUpdateText) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TMssqlWriteText) {
                                stmtStack.push(stmt);
                                analyzeMssqlWriteTextStmt((TMssqlWriteText) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TMssqlReadText) {
                                stmtStack.push(stmt);
                                analyzeMssqlReadTextStmt((TMssqlReadText) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TExecuteSqlStatement) {
                                String sqlText = ((TExecuteSqlStatement) stmt).getPreparedSqlText();
                                if(sqlText == null) {
                                        sqlText = ((TExecuteSqlStatement) stmt).getSqlText();
                                }
                                if (!option.isAnalyzeDynamicSql()) {
                                        if (sqlText != null
                                                        || ((TExecuteSqlStatement) stmt).getStmtString() != null) {
                                                modelManager.collectDynamicSqlHash(stmt);
                                                recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.OTHER,
                                                                DynamicSqlSite.Status.UNRESOLVED,
                                                                "dynamic SQL inner analysis disabled");
                                        }
                                } else if (sqlText != null) {
                                        modelManager.collectDynamicSqlHash(stmt);
                                        TGSqlParser sqlparser = createSqlParser(option.getVendor());
                                        sqlparser.sqltext = SQLUtil.trimColumnStringQuote(sqlText);
                                        // each %s of format() a runtime argument fills: the endpoint it names is a template, not a
                                        // table named PLACEHOLDER (Mantis 4880)
                                        List<FoldHole> formatHoles = formatHoles((TExecuteSqlStatement) stmt, sqlparser.sqltext);
                                        Set<Table> templateTablesBefore = snapshotTemplateCandidateTables(!formatHoles.isEmpty());
                                        int result = parseWithCommentBindings(sqlparser);
                                        if (result != 0) {
                                                errors = sqlparser.getSyntaxErrors();
                                                if (errors != null && !errors.isEmpty()) {
                                                        for (int i = 0; i < errors.size(); i++) {
                                                                TSyntaxError error = errors.get(i);
                                                                ErrorInfo errorInfo = new ErrorInfo();
                                                                errorInfo.setErrorType(ErrorInfo.SYNTAX_ERROR);
                                                                errorInfo.setErrorMessage(getErrorMessage(error, ErrorInfo.SYNTAX_ERROR));
                                                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(error.lineNo, error.columnNo,
                                                                                ModelBindingManager.getGlobalHash()));
                                                                String[] segments = error.tokentext.split("\n");
                                                                if (segments.length == 1) {
                                                                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(error.lineNo,
                                                                                        error.columnNo + error.tokentext.length(),
                                                                                        ModelBindingManager.getGlobalHash()));
                                                                } else {
                                                                        errorInfo.setEndPosition(
                                                                                        new Pair3<Long, Long, String>(error.lineNo + segments.length - 1,
                                                                                                        (long) segments[segments.length - 1].length() + 1,
                                                                                                        ModelBindingManager.getGlobalHash()));
                                                                }
                                                                errorInfo.fillInfo(this);
                                                                errorInfos.add(errorInfo);
                                                        }
                                                }
                                        } else if (sqlparser.sqlstatements != null) {
                                                dynamicFoldDepth++;
                                                try {
                                                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                                                if (formatHoles.isEmpty()) {
                                                                        // text without a hole names real objects, as a static statement does
                                                                        applyStaticTemplateVetoes(sqlparser.sqlstatements.get(i));
                                                                }
                                                                analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                                        }
                                                } finally {
                                                        dynamicFoldDepth--;
                                                }
                                                markDynamicTemplateEndpoints(templateTablesBefore, sqlparser, formatHoles);
                                        }
                                }
                                else if (((TExecuteSqlStatement) stmt).getStmtString() != null) {
                                        modelManager.collectDynamicSqlHash(stmt);
                                }
                        } else if (stmt instanceof TMssqlExecute) {
                                TMssqlExecute executeStmt = (TMssqlExecute)stmt;
                                if (!option.isAnalyzeDynamicSql()
                                                && expandsDynamicSql(executeStmt)) {
                                        modelManager.collectDynamicSqlHash(stmt);
                                        recordDynamicSqlSite(stmt, dynamicKindOf(executeStmt),
                                                        DynamicSqlSite.Status.UNRESOLVED,
                                                        "dynamic SQL inner analysis disabled");
                                } else if (executeStmt.getSqlText() != null) {
                                        modelManager.collectDynamicSqlHash(stmt);
                                        boolean evalHandled = false;
                                        DynamicSqlTrustMode trustMode = option.getDynamicSqlTrustMode();
                                        boolean nonLiteralDynamicArg = !isLiteralDynamicArg(executeStmt);
                                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite evalSite = null;
                                        if (nonLiteralDynamicArg) {
                                                evalSite = evaluatedDynamicSqlFor(stmt);
                                                // Abstract evaluation fully materialized one or more strings
                                                // (constant relation rows and/or literal call bindings). Analyze
                                                // every distinct concrete variant in stable evidence order.
                                                evalHandled = analyzeEvaluatedDynamicSqlVariants(stmt,
                                                                dynamicKindOf(executeStmt), true);
                                        }
                                        boolean evaluatorProofUnavailable = nonLiteralDynamicArg
                                                        && (evalSite == null || evalSite.sqlText == null
                                                                        || evalSite.provenanceIncomplete);
                                        boolean provenanceIncomplete = trustMode == DynamicSqlTrustMode.SHADOW
                                                        && evaluatorProofUnavailable;
                                        // Hole evidence is a property of the ARGUMENT's provenance as the
                                        // evaluator saw it (which variable, assigned from what, where), not
                                        // of the text analyzed below - the evaluator and the legacy fold
                                        // render the same expression differently (@DeleteWhere vs a dropped
                                        // tail), but its holes are the same holes. Hole SPANS inside the
                                        // analyzed text remain text-gated (markDynamicTemplateEndpoints).
                                        // Whenever the evaluator saw the node its verdict stands, including
                                        // "not known" (-1). Only without an evaluator view (no enclosing
                                        // procedure) does the legacy rule apply: SHADOW says unknown, LEGACY
                                        // keeps its historical zero.
                                        DynamicHoleEvidence holeEvidence = dynamicHoleEvidence(evalSite);
                                        int trustHoleCount = evalSite != null ? holeEvidence.count
                                                        : (provenanceIncomplete ? -1 : 0);
                                        boolean trustHoleCountExact = evalSite != null ? holeEvidence.exact
                                                        : !provenanceIncomplete;
                                        if (!evalHandled && nonLiteralDynamicArg && provenNullReasonOf(stmt) != null) {
                                                // every variant of the string is NULL for a reason the evaluation proves (EXEC of NULL runs
                                                // nothing): the token fold must not publish what it would make of it. A variant without text
                                                // for any other reason leaves the fold its say: it keeps the edges the literal parts prove
                                                // (Mantis 4962)
                                                recordUnresolvedDynamicSqlSite(stmt, executeStmt, dynamicKindOf(executeStmt));
                                                evalHandled = true;
                                        }
                                        if (!evalHandled) {
                                        TGSqlParser sqlparser = createSqlParser(option.getVendor());
                                        sqlparser.sqltext = ((TMssqlExecute) stmt).getSqlText();
                                        Set<Relationship> shadowBefore = provenanceIncomplete
                                                        && trustMode == DynamicSqlTrustMode.SHADOW
                                                        ? snapshotDynamicRelationships() : null;
                                        int relsBeforeDynamic = modelManager.getRelations().length;
                                        int dynamicSitesBefore = dynamicSqlSites.size();
                                        // A data-driven argument (variable / expression) is at most PARTIALLY folded:
                                        // GSP keeps the literal pieces but drops the unresolved trailing @var, leaving a
                                        // legitimately truncated fragment (e.g. "... WHERE " with no predicate -> end of
                                        // input). A parse failure on such text says nothing about the real SQL, so we must
                                        // not surface it as a unit SYNTAX_ERROR — that would discard the whole procedure's
                                        // lineage even though the outer parse succeeded. Only a true compile-time literal
                                        // EXEC('...') surfaces inner parse failures (mirrors the EXECUTE IMMEDIATE
                                        // isDynamicSQLPartial() guard below).
                                        boolean literalArg = isLiteralDynamicArg(executeStmt);
                                        // A partial fold leaves the unresolved @var / @param remnant in the folded
                                        // text. Decided BEFORE the inner analysis so the endpoints this site
                                        // introduces can be told apart from the ones that already existed, and so
                                        // a fully-resolved fold pays nothing (snapshot returns null).
                                        boolean maybePartialFold = !literalArg
                                                        && ((TMssqlExecute) stmt).getSqlText().matches("(?s).*@\\w+.*");
                                        // The conservative @\w+ test is not the only way a hole can be present:
                                        // the evaluator may know this fold has value-unknown holes whose legacy
                                        // rendering carries no '@' (UPPER(@X) folds to the bare function name).
                                        // Snapshot whenever EITHER tier could fire, so provenance is never wasted.
                                        Set<Table> templateTablesBefore = snapshotTemplateCandidateTables(maybePartialFold
                                                        || hasValueUnknownHole(evalSite));
                                        boolean foldStatementsAnalyzed = false;
                                        int result = parseWithCommentBindings(sqlparser);
                                        if (result == 0 && sqlparser.sqltext != null) {
                                                // where the text came from (Mantis 4851): a literal argument's own token; else the
                                                // evaluator's fragments, when they spell the same text. Otherwise positions stay the text's
                                                List<gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment> provenance = null;
                                                if (literalArg) {
                                                        TExpression arg = dynamicArgOf(executeStmt);
                                                        gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment.SourcePiece piece = arg != null
                                                                        && arg.getStartToken() != null && arg.getStartToken() == arg.getEndToken()
                                                                        ? gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment.SourcePiece.of(
                                                                                        arg.getStartToken(), sqlparser.sqltext)
                                                                        : null;
                                                        if (piece != null) {
                                                                provenance = Collections.singletonList(
                                                                                gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment.literal(sqlparser.sqltext, piece));
                                                        } else {
                                                                // several literals ('a' + 'b'): the evaluator's fragments hold one piece each
                                                                gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite literalSite =
                                                                                evaluatedDynamicSqlFor(stmt);
                                                                if (literalSite != null && sqlparser.sqltext.equals(literalSite.sqlText)) {
                                                                        provenance = literalSite.fragments;
                                                                }
                                                        }
                                                } else if (evalSite != null && sqlparser.sqltext.equals(evalSite.sqlText)) {
                                                        provenance = evalSite.fragments;
                                                }
                                                if (provenance != null) {
                                                        remapDynamicPositions(sqlparser, provenance, stmt);
                                                }
                                        }
                                        if (result != 0) {
                                                errors = literalArg ? sqlparser.getSyntaxErrors() : null;
                                                if (errors != null && !errors.isEmpty()) {
                                                        for (int i = 0; i < errors.size(); i++) {
                                                                TSyntaxError error = errors.get(i);
                                                                ErrorInfo errorInfo = new ErrorInfo();
                                                                errorInfo.setErrorType(ErrorInfo.SYNTAX_ERROR);
                                                                errorInfo.setErrorMessage(getErrorMessage(error, ErrorInfo.SYNTAX_ERROR));
                                                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(error.lineNo, error.columnNo,
                                                                                ModelBindingManager.getGlobalHash()));
                                                                String[] segments = error.tokentext.split("\n");
                                                                if (segments.length == 1) {
                                                                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(error.lineNo,
                                                                                        error.columnNo + error.tokentext.length(),
                                                                                        ModelBindingManager.getGlobalHash()));
                                                                } else {
                                                                        errorInfo.setEndPosition(
                                                                                        new Pair3<Long, Long, String>(error.lineNo + segments.length - 1,
                                                                                                        (long) segments[segments.length - 1].length() + 1,
                                                                                                        ModelBindingManager.getGlobalHash()));
                                                                }
                                                                errorInfo.fillInfo(this);
                                                                errorInfos.add(errorInfo);
                                                        }
                                                }
                                        } else if (sqlparser.sqlstatements != null) {
                                                foldStatementsAnalyzed = true;
                                                List<TConstant> templatedFiles = templateTablesBefore == null
                                                                ? Collections.<TConstant>emptyList() : noteTemplatedLoadFiles(evalSite, sqlparser);
                                                dynamicFoldDepth++;
                                                try {
                                                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                                                analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                                        }
                                                } finally {
                                                        dynamicFoldDepth--;
                                                        forgetTemplatedLoadFiles(templatedFiles);
                                                }
                                        }
                                        // getSqlText()!=null means GSP folded the dynamic text. RESOLVED only when the argument
                                        // was a compile-time literal AND it parsed; a variable/expression argument is data-driven
                                        // (often only partially folded, e.g. an unresolved @parameter left in) -> UNRESOLVED.
                                        // NOTE: a variable
                                        // argument whose folded text fails to parse deliberately stays UNRESOLVED,
                                        // not PARSE_ERROR — the fold is flow-insensitive (the variable may hold a
                                        // different value at runtime), so a parse failure on folded text says
                                        // nothing definitive about the real SQL. Only a compile-time literal
                                        // argument earns PARSE_ERROR.
                                        // Land the placeholder verdict on the model NODES, not only on the site
                                        // status: exact hole spans when the evaluator described this very text,
                                        // literal-aligned spans when it described the same fold's other rendering,
                                        // otherwise the conservative @\w+ scan of the legacy fold.
                                        if (foldStatementsAnalyzed) {
                                                markDynamicTemplateEndpoints(templateTablesBefore, evalSite, sqlparser);
                                        }
                                        int[] dynCounts = classifyDynamicSiteLineage(relsBeforeDynamic, maybePartialFold);
                                        int unprovenCount = countNewDynamicRelationships(shadowBefore);
                                        if (!literalArg) {
                                                // Truthful status: a fold that yielded clean lineage into base tables
                                                // — or a pure dynamic SELECT whose only product is its projection —
                                                // is RESOLVED (with counts). Placeholder-contaminated, partial-target,
                                                // or empty outcomes stay UNRESOLVED with an accurate reason.
                                                boolean usable = dynCounts[2] == 0
                                                                && (dynCounts[0] > 0 || (dynCounts[1] == 0 && dynCounts[3] > 0));
                                                if (provenanceIncomplete && trustMode == DynamicSqlTrustMode.SHADOW) {
                                                        recordDynamicSqlSite(stmt, dynamicKindOf(executeStmt),
                                                                        unprovenCount > 0 ? DynamicSqlSite.Status.PARTIAL
                                                                                        : DynamicSqlSite.Status.UNRESOLVED,
                                                                dynamicTrustReason("SHADOW retained legacy publication behavior",
                                                                                unprovenCount, trustHoleCount, trustHoleCountExact),
                                                                dynCounts[0], dynCounts[1], unprovenCount,
                                                                trustHoleCount, trustHoleCountExact, trustMode,
                                                                relsBeforeDynamic, dynamicSitesBefore, null,
                                                                evalSite == null ? null : evalSite.executionNote,
                                                                holeEvidence.fragments, holeEvidence.materializedText,
                                                                evalSite == null || evalSite.executionCertain);
                                                } else {
                                                        recordDynamicSqlSite(stmt, dynamicKindOf(executeStmt),
                                                                        usable ? DynamicSqlSite.Status.RESOLVED : DynamicSqlSite.Status.UNRESOLVED,
                                                                        usable ? null
                                                                                        : (dynCounts[2] != 0
                                                                                                        ? "dynamic SQL references a runtime-built object name; lineage source is a placeholder"
                                                                                                        : dynamicReasonOf(executeStmt)),
                                                                        dynCounts[0], dynCounts[1], 0,
                                                                        trustHoleCount, trustHoleCountExact, trustMode,
                                                                        relsBeforeDynamic, dynamicSitesBefore, null,
                                                                        evalSite == null ? null : evalSite.executionNote,
                                                                        holeEvidence.fragments, holeEvidence.materializedText,
                                                                        evalSite == null || evalSite.executionCertain);
                                                }
                                        } else {
                                                // a literal argument needs no evaluation, but whether the statement runs is the evaluator's
                                                // to say: in a CATCH block or behind an undecidable condition it may not (Mantis 4962)
                                                gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite position =
                                                                evaluatedDynamicSqlFor(stmt);
                                                recordDynamicSqlSite(stmt, dynamicKindOf(executeStmt),
                                                                result != 0 ? DynamicSqlSite.Status.PARSE_ERROR : DynamicSqlSite.Status.RESOLVED,
                                                                result != 0 ? "inner dynamic SQL failed to parse" : null,
                                                                dynCounts[0], dynCounts[1], 0, 0, true, trustMode,
                                                                relsBeforeDynamic, dynamicSitesBefore, null,
                                                                position == null ? null : position.executionNote,
                                                                Collections.<UnresolvedFragment>emptyList(), executeStmt.getSqlText(),
                                                                position == null || position.executionCertain);
                                        }
                                        }
                                } else if (executeStmt.getModuleName() != null) {
                                        // getSqlText()==null here: a folded literal would have set sqlText. So this is either an
                                        // opaque sp_executesql (data-driven argument), a dynamic proc name (EXEC @var), or an
                                        // ordinary static procedure call. Record the dynamic ones; leave static EXEC proc alone.
                                        boolean evalHandledSite = false;
                                        if (isSpExecutesql(executeStmt.getModuleName())) {
                                                evalHandledSite = analyzeEvaluatedDynamicSqlVariants(stmt,
                                                                DynamicSqlSite.Kind.SP_EXECUTESQL, false);
                                                if (!evalHandledSite) {
                                                        recordUnresolvedDynamicSqlSite(stmt, executeStmt,
                                                                        DynamicSqlSite.Kind.SP_EXECUTESQL);
                                                }
                                        } else if (executeStmt.getModuleName().toString().startsWith("@")) {
                                                // EXEC @var is SQL Server's @module_name_var form: the variable
                                                // holds a PROCEDURE NAME, not SQL text (parenthesized EXEC(@var)
                                                // arrives as metExecStringCmd below) - never evaluate it as SQL.
                                                recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.OTHER,
                                                                DynamicSqlSite.Status.UNRESOLVED, "EXEC target procedure name is a runtime variable");
                                        }
                                        if (!evalHandledSite && isSpExecutesql(executeStmt.getModuleName())
                                                        && provenNullReasonOf(stmt) != null) {
                                                // its string is NULL for certain: the evaluation decided the site although it gave no text, and
                                                // the legacy token path must not publish its own rendering (Mantis 4962)
                                                evalHandledSite = true;
                                        }
                                        if (!evalHandledSite) {
                                                // When evaluation already analyzed the materialized batch, the
                                                // legacy path would re-execute the same argument and duplicate
                                                // every process/edge - skip it.
                                                stmtStack.push(stmt);
                                                analyzeMssqlExecute(executeStmt);
                                                stmtStack.pop();
                                        }
                                } else if (executeStmt.getExecType() == TBaseType.metExecStringCmd) {
                                        // EXEC(<expr>) whose string was not folded: try the no-bindings abstract
                                        // evaluation (template/constant-built strings); otherwise honestly UNRESOLVED.
                                        if (!analyzeEvaluatedDynamicSqlVariants(stmt,
                                                        DynamicSqlSite.Kind.EXEC_STRING, false)) {
                                                recordUnresolvedDynamicSqlSite(stmt, executeStmt,
                                                                DynamicSqlSite.Kind.EXEC_STRING);
                                        }
                                }
                        } else if (stmt instanceof TExecImmeStmt) {
                                TExecImmeStmt execImmeStmt = (TExecImmeStmt) stmt;
                                modelManager.collectDynamicSqlHash(stmt);
                                if (!option.isAnalyzeDynamicSql()) {
                                        recordDynamicSqlSite(stmt,
                                                        DynamicSqlSite.Kind.EXECUTE_IMMEDIATE,
                                                        DynamicSqlSite.Status.UNRESOLVED,
                                                        "dynamic SQL inner analysis disabled");
                                        return;
                                }
                                synchronized (DataFlowAnalyzer.class) {
                                        int relsBeforeDynamic = modelManager.getRelations().length;
                                        int dynamicSitesBefore = dynamicSqlSites.size();
                                        boolean analyzedInner = false;
                                        boolean innerParseFailed = false;
                                        // PL/SQL call-site binding (plan Phase 5): when the token fold left
                                        // this site partial or empty, interpret the file's statements (plus
                                        // literal callers harvested from other files of a multi-file
                                        // analysis) so parameter-dependent templates can fold fully.
                                        // getDynamicStatements() below then reads the evaluated text.
                                        maybeEvaluatePlsqlDynamicSql(execImmeStmt);
                                        DynamicSqlTrustMode trustMode = option.getDynamicSqlTrustMode();
                                        boolean legacyPartialFold = execImmeStmt.isDynamicSQLPartial();
                                        boolean shadowIncomplete = legacyPartialFold
                                                        && execImmeStmt.getEvaluatedDynamicSQLs().isEmpty();
                                        Set<Relationship> shadowBefore = shadowIncomplete
                                                        && trustMode == DynamicSqlTrustMode.SHADOW
                                                        ? snapshotDynamicRelationships() : null;
                                        TStatementList stmts = execImmeStmt.getDynamicStatements();
                                        if (stmts != null && stmts.size() > 0) {
                                                dynamicFoldDepth++;
                                                try {
                                                        for (int i = 0; i < stmts.size(); i++) {
                                                                analyzeCustomSqlStmt(stmts.get(i));
                                                        }
                                                } finally {
                                                        dynamicFoldDepth--;
                                                }
                                                analyzedInner = true;
                                        }

                                        // Only re-parse the raw dynamic SQL when getDynamicStatements()
                                        // produced nothing. getDynamicStatements() already parses and
                                        // analyzes the fragment with coordinates remapped back to the
                                        // original file position; re-parsing it here with a fresh parser
                                        // would analyze the same SQL a second time and emit duplicate
                                        // hints/lineage carrying fragment-relative (un-remapped)
                                        // coordinates. This fallback still covers the case where
                                        // getDynamicStatements() failed (e.g. dynamic SQL syntax error),
                                        // reporting the parse error below.
                                        String dynamicSql = (stmts == null || stmts.size() == 0) ? execImmeStmt.getDynamicSQL() : null;
                                        if (!SQLUtil.isEmpty(dynamicSql)) {
                                                TGSqlParser sqlparser = createSqlParser(option.getVendor());
                                                sqlparser.sqltext = dynamicSql;
                                                int result = parseWithCommentBindings(sqlparser);
                                                        // This fresh parse runs the dynamic SQL un-padded, so its
                                                        // coordinates are relative to the fragment (first char at
                                                        // line 1). Shift them back to the position the fragment
                                                        // occupies in the original file, mirroring the shift
                                                        // TExecImmeStmt.getDynamicStatements() applies; otherwise
                                                        // fallback parse errors for EXECUTE IMMEDIATE text located
                                                        // later in the file would report fragment-relative lines.
                                                        if (execImmeStmt.getDynamicStringExpr() != null
                                                                        && execImmeStmt.getDynamicStringExpr().getPlainTextLineNo() != -1) {
                                                                int deltaLine = (int) execImmeStmt.getDynamicStringExpr().getPlainTextLineNo() - 1;
                                                                int deltaColumn = (int) execImmeStmt.getDynamicStringExpr().getPlainTextColumnNo();
                                                                if ((deltaLine != 0 || deltaColumn != 0) && sqlparser.getSyntaxErrors() != null) {
                                                                        for (int ei = 0; ei < sqlparser.getSyntaxErrors().size(); ei++) {
                                                                                TSyntaxError dynErr = sqlparser.getSyntaxErrors().get(ei);
                                                                                if (dynErr == null) continue;
                                                                                boolean onFirstLine = (dynErr.lineNo == 1);
                                                                                dynErr.lineNo += deltaLine;
                                                                                if (onFirstLine) dynErr.columnNo += deltaColumn;
                                                                        }
                                                                }
                                                        }
                                                if (result != 0) {
                                                        innerParseFailed = true;
                                                        // a partially resolved value contains placeholder identifiers
                                                        // for unknowable parts; a parse failure on such text says
                                                        // nothing about the real SQL, so don't report it
                                                        errors = execImmeStmt.isDynamicSQLPartial() ? null : sqlparser.getSyntaxErrors();
                                                        if (errors != null && !errors.isEmpty()) {
                                                                for (int i = 0; i < errors.size(); i++) {
                                                                        TSyntaxError error = errors.get(i);
                                                                        ErrorInfo errorInfo = new ErrorInfo();
                                                                        errorInfo.setErrorType(ErrorInfo.SYNTAX_ERROR);
                                                                        errorInfo.setErrorMessage(getErrorMessage(error, ErrorInfo.SYNTAX_ERROR));
                                                                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(error.lineNo, error.columnNo,
                                                                                        ModelBindingManager.getGlobalHash()));
                                                                        String[] segments = error.tokentext.split("\n");
                                                                        if (segments.length == 1) {
                                                                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(error.lineNo,
                                                                                                error.columnNo + error.tokentext.length(),
                                                                                                ModelBindingManager.getGlobalHash()));
                                                                        } else {
                                                                                errorInfo.setEndPosition(
                                                                                                new Pair3<Long, Long, String>(error.lineNo + segments.length - 1,
                                                                                                                (long) segments[segments.length - 1].length() + 1,
                                                                                                                ModelBindingManager.getGlobalHash()));
                                                                        }
                                                                        errorInfo.fillInfo(this);
                                                                        errorInfos.add(errorInfo);
                                                                }
                                                        }
                                                } else if (sqlparser.sqlstatements != null) {
                                                        dynamicFoldDepth++;
                                                        try {
                                                                for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                                                        analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                                                }
                                                        } finally {
                                                                dynamicFoldDepth--;
                                                        }
                                                        analyzedInner = true;
                                                }
                                        }
                                        // Site accounting mirrors the T-SQL EXEC branch: every
                                        // EXECUTE IMMEDIATE is a dynamic site; status reflects what
                                        // the analyzer actually did with it.
                                        boolean partialFold = legacyPartialFold;
                                        int[] dynCounts = classifyDynamicSiteLineage(relsBeforeDynamic, partialFold);
                                        int unprovenCount = countNewDynamicRelationships(shadowBefore);
                                        boolean fullyKnown = analyzedInner && !partialFold;
                                        boolean usableLineage = dynCounts[2] == 0
                                                        && (dynCounts[0] > 0 || (dynCounts[1] == 0 && dynCounts[3] > 0));
                                        if (shadowIncomplete && trustMode == DynamicSqlTrustMode.SHADOW) {
                                                DynamicSqlSite.Status status = analyzedInner && unprovenCount > 0
                                                                ? DynamicSqlSite.Status.PARTIAL : DynamicSqlSite.Status.UNRESOLVED;
                                                recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.EXECUTE_IMMEDIATE, status,
                                                                dynamicTrustReason("SHADOW retained legacy publication behavior",
                                                                                unprovenCount, -1, false),
                                                                dynCounts[0], dynCounts[1], unprovenCount,
                                                                -1, false, trustMode,
                                                                relsBeforeDynamic, dynamicSitesBefore);
                                        } else if (analyzedInner && (fullyKnown || usableLineage)) {
                                                recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.EXECUTE_IMMEDIATE,
                                                                DynamicSqlSite.Status.RESOLVED, null, dynCounts[0], dynCounts[1],
                                                                0, 0, true, trustMode,
                                                                relsBeforeDynamic, dynamicSitesBefore);
                                        } else if (innerParseFailed && !partialFold) {
                                                recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.EXECUTE_IMMEDIATE,
                                                                DynamicSqlSite.Status.PARSE_ERROR, "inner dynamic SQL failed to parse",
                                                                dynCounts[0], dynCounts[1], 0, 0, true, trustMode,
                                                                relsBeforeDynamic, dynamicSitesBefore);
                                        } else if (innerParseFailed) {
                                                recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.EXECUTE_IMMEDIATE,
                                                                DynamicSqlSite.Status.UNRESOLVED,
                                                                "partially folded dynamic SQL failed to parse; unresolved parts remain",
                                                                dynCounts[0], dynCounts[1], 0, -1, false, trustMode,
                                                                relsBeforeDynamic, dynamicSitesBefore);
                                        } else if (analyzedInner) {
                                                recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.EXECUTE_IMMEDIATE,
                                                                DynamicSqlSite.Status.UNRESOLVED,
                                                                        dynCounts[2] != 0
                                                                                        ? "dynamic SQL references a runtime-built object name; lineage source is a placeholder"
                                                                                        : "dynamic SQL only partially folded; no resolved lineage produced",
                                                                dynCounts[0], dynCounts[1], 0, -1, false, trustMode,
                                                                relsBeforeDynamic, dynamicSitesBefore);
                                        } else {
                                                boolean runtimeTextUnavailable = !analyzedInner
                                                                && execImmeStmt.getDynamicSQL() == null;
                                                boolean unresolvedFragments = partialFold || runtimeTextUnavailable;
                                                recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.EXECUTE_IMMEDIATE,
                                                                DynamicSqlSite.Status.UNRESOLVED,
                                                                "dynamic SQL string is a runtime value; no statically-known text to analyze",
                                                                dynCounts[0], dynCounts[1], 0,
                                                                unresolvedFragments ? -1 : 0, !unresolvedFragments, trustMode,
                                                                relsBeforeDynamic, dynamicSitesBefore);
                                        }
                                }
                        } else if (stmt instanceof TCallStatement) {
                                TCallStatement callStmt = (TCallStatement)stmt;
                                stmtStack.push(stmt);
                                analyzeCallStmt(callStmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TDb2CallStmt) {
                                TDb2CallStmt db2CallStmt = (TDb2CallStmt) stmt;
                                stmtStack.push(stmt);
                                analyzeDb2CallStmt(db2CallStmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TBasicStmt) {
                                TBasicStmt oracleBasicStmt = (TBasicStmt) stmt;
                                stmtStack.push(stmt);
                                analyzeOracleBasicStmt(oracleBasicStmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TIfStmt) {
                                TIfStmt ifStmt = (TIfStmt) stmt;
                                stmtStack.push(stmt);
                                analyzeIfStmt(ifStmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TElsifStmt) {
                                TElsifStmt elsIfStmt = (TElsifStmt) stmt;
                                stmtStack.push(stmt);
                                analyzeElsIfStmt(elsIfStmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TMssqlIfElse) {
                                TMssqlIfElse ifStmt = (TMssqlIfElse) stmt;
                                stmtStack.push(stmt);
                                analyzeMssqlIfElseStmt(ifStmt);
                                stmtStack.pop();
                        } else if (stmt.getStatements() != null && stmt.getStatements().size() > 0) {
                                for (int i = 0; i < stmt.getStatements().size(); i++) {
                                        analyzeCustomSqlStmt(stmt.getStatements().get(i));
                                }
                        } else if (stmt instanceof TCreateIndexSqlStatement) {
                                stmtStack.push(stmt);
                                analyzeCreateIndexStageStmt((TCreateIndexSqlStatement) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof gudusoft.gsqlparser.stmt.mdx.TMdxSelect) {
                                stmtStack.push(stmt);
                                analyzeMdxSelectStmt((gudusoft.gsqlparser.stmt.mdx.TMdxSelect) stmt);
                                stmtStack.pop();
                        } else if (stmt instanceof TPowerQueryDocumentStmt) {
                                stmtStack.push(stmt);
                                analyzePowerQueryDocumentStmt((TPowerQueryDocumentStmt) stmt);
                                stmtStack.pop();
                        }
                } catch (Exception e) {
                        if (sqllrProducerMode()) {
                                // SQL-LR production: a statement whose analysis failed is reported FAILED by the top-level boundary
                                // in analyzeCustomSqlStmt, which also restores the statement stack; nothing it built is published
                                if (e instanceof RuntimeException) {
                                        throw (RuntimeException) e;
                                }
                                throw new IllegalStateException(e);
                        }
            StringBuffer errorMessage = new StringBuffer();
            errorMessage.append("analyze sql stmt failed, ");
            if (stmt.getStartToken() != null) {
                errorMessage.append("line: " + stmt.getStartToken().lineNo + ", column: " + stmt.getStartToken().columnNo).append(", ");
            }
            if (stmt.getGsqlparser() != null && !SQLUtil.isEmpty(stmt.getGsqlparser().sqlfilename)) {
                errorMessage.append("file: "+ stmt.getGsqlparser().sqlfilename).append(", ");
            }
            if (stmt.toString() != null) {
                errorMessage.append("sql:\n" + stmt.toString());
            }
            logger.error(errorMessage.toString(), e);
                        ErrorInfo errorInfo = new ErrorInfo();
                        errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                        if (e.getMessage() == null) {
                                if (e.getStackTrace() != null && e.getStackTrace().length > 0) {
                                        errorInfo.setErrorMessage(e.getClass().getSimpleName() + ": " + e.getStackTrace()[0].toString());
                                } else {
                                        errorInfo.setErrorMessage(e.getClass().getSimpleName());
                                }
                        } else {
                                errorInfo.setErrorMessage(e.getClass().getSimpleName() + ": " + e.getMessage());
                        }
                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(stmt.getStartToken().lineNo,
                                        stmt.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                        String[] segments = stmt.getEndToken().getAstext().split("\n", -1);
                        if (segments.length == 1) {
                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(stmt.getEndToken().lineNo,
                                                stmt.getEndToken().columnNo + stmt.getEndToken().getAstext().length(),
                                                ModelBindingManager.getGlobalHash()));
                        } else {
                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(stmt.getEndToken().lineNo + segments.length - 1,
                                                (long) segments[segments.length - 1].length() + 1, ModelBindingManager.getGlobalHash()));
                        }
                        errorInfo.fillInfo(this);
                        errorInfos.add(errorInfo);
                }
        }

        private void analyzePlsqlRecordTypeDefStmt(TPlsqlRecordTypeDefStmt stmt) {
                TObjectName typeName = stmt.getTypeName();
                Variable variable = modelFactory.createVariable(typeName);
                variable.setSubType(SubType.record_type);
        
                if (stmt.getFieldDeclarations() != null) {
                        for (int i = 0; i < stmt.getFieldDeclarations().size(); i++) {
                                TParameterDeclaration param = stmt.getFieldDeclarations().getParameterDeclarationItem(i);
                                TTypeName dataType = param.getDataType();
                                TObjectName columnName = param.getParameterName();      
                                TableColumn variableProperty = modelFactory.createTableColumn(variable, columnName, true);
                                boolean columnTypeAnchor = false;
                                for (int j = 0; j < dataType.getDatatypeAttributeList().size(); j++) {
                                        if (dataType.getDatatypeAttributeList().getElement(j).getAttributeType()
                                                        == EDataTypeAttribute.plsql_type_t) {
                                                columnTypeAnchor = true;
                                                break;
                                        }
                                }
                                TObjectName typeColumn = dataType.getDataTypeObjectName();
                                if (columnTypeAnchor && typeColumn != null && typeColumn.getObjectToken() != null) {
                                        // Use the parsed qualifier, not the last dot in the rendered name:
                                        // a quoted column such as "Last.Name" contains a dot of its own.
                                        TObjectName tableName = typeColumn.getSchemaToken() == null
                                                        ? TObjectName.createObjectName(option.getVendor(), EDbObjectType.table,
                                                                        typeColumn.getObjectToken())
                                                        : TObjectName.createObjectName(option.getVendor(), EDbObjectType.table,
                                                                        typeColumn.getSchemaToken(), typeColumn.getObjectToken());
                                        Table table = modelFactory.createTypeAnchor(tableName);
                                        if(table!=null) {
                                                TableColumn tableColumn = modelFactory.createInsertTableColumn(table, typeColumn);
                                                if (tableColumn != null) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.rowtype);
                                                        relation.setTarget(new TableColumnRelationshipElement(variableProperty));
                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                }
                                        }
                                }
                        }
                        variable.setDetermined(true);
                }
                else {
                        TObjectName starColumn = DlineageUtil.syntheticStarName();
                }
        }
        
        private void analyzePlsqlTableTypeDefStmt(TPlsqlTableTypeDefStmt stmt) {
                TTypeName typeName = stmt.getElementDataType();
                if (typeName != null && typeName.toString().toUpperCase(Locale.ROOT).indexOf("ROWTYPE") != -1) {
                        Variable cursorVariable = modelFactory.createVariable(stmt.getTypeName());
                        cursorVariable.setSubType(SubType.record_type);

                        Table variableTable = modelFactory.createRowTypeAnchor(typeName.getDataTypeName());
                        if(!variableTable.isCreateTable()) {
                                TObjectName starColumn1 = DlineageUtil.syntheticStarName();
                                TableColumn variableTableStarColumn = modelFactory.createTableColumn(variableTable, starColumn1, true);
                                variableTableStarColumn.setShowStar(false);
                                variableTableStarColumn.setExpandStar(true);

                                TObjectName starColumn = DlineageUtil.syntheticStarName();
                                TableColumn variableProperty = modelFactory.createTableColumn(cursorVariable, starColumn, true);
                                variableProperty.setShowStar(false);
                                variableProperty.setExpandStar(true);

                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                dataflowRelation.setEffectType(EffectType.rowtype);
                                dataflowRelation.addSource(new TableColumnRelationshipElement(variableTableStarColumn));
                                dataflowRelation.setTarget(new TableColumnRelationshipElement(variableProperty));
                        } else {
                                for (TableColumn sourceColumn : variableTable.getColumns()) {
                                        String columnName = sourceColumn.getName();
                                        TObjectName targetColumn = new TObjectName();
                                        targetColumn.setString(columnName);
                                        TableColumn variableProperty = modelFactory.createTableColumn(cursorVariable, targetColumn, true);
                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                        dataflowRelation.setEffectType(EffectType.rowtype);
                                        dataflowRelation.addSource(new TableColumnRelationshipElement(sourceColumn));
                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(variableProperty));
                                }
                        }
                } 
        }

        private void analyzeMssqlCreateType(TMssqlCreateType createType) {

        }

        /**
         * UPDATETEXT table.dest_column dest_text_ptr {NULL|offset} {NULL|del_len}
         * [WITH LOG] [inserted_data | table.src_column src_text_ptr] (Mantis #4607).
         * The written column is a real data-write target: emit inserted_data (variable
         * or literal) -&gt; dest column, and for the column-copy form the proven
         * src_column -&gt; dest_column edge.
         */
        private void analyzeMssqlUpdateTextStmt(TMssqlUpdateText stmt) {
                TableColumn destColumn = createTextPtrTargetColumn(stmt.getTargetTable(), stmt.getDestColumnName());
                if (destColumn == null) {
                        return;
                }
                List<TObjectName> sourceNames = new ArrayList<TObjectName>();
                if (stmt.getInsertedVariable() != null) {
                        sourceNames.add(stmt.getInsertedVariable());
                }
                if (stmt.getSourceColumnName() != null && stmt.getCopySourceTable() != null) {
                        // make sure the copy-source table has a model so the edge resolves
                        modelFactory.createTable(stmt.getCopySourceTable());
                        sourceNames.add(stmt.getSourceColumnName());
                }
                if (!sourceNames.isEmpty()) {
                        analyzeDataFlowRelation(destColumn, sourceNames, EffectType.update, null);
                }
                if (stmt.getInsertedLiteral() != null) {
                        List<TParseTreeNode> constants = new ArrayList<TParseTreeNode>();
                        constants.add(stmt.getInsertedLiteral());
                        analyzeConstantDataFlowRelation(destColumn, constants, EffectType.update, null);
                }
        }

        /** WRITETEXT table.column text_ptr [WITH LOG] data (Mantis #4607): data -&gt; column. */
        private void analyzeMssqlWriteTextStmt(TMssqlWriteText stmt) {
                TableColumn destColumn = createTextPtrTargetColumn(stmt.getTargetTable(), stmt.getDestColumnName());
                if (destColumn == null) {
                        return;
                }
                if (stmt.getWriteDataVariable() != null) {
                        List<TObjectName> sourceNames = new ArrayList<TObjectName>();
                        sourceNames.add(stmt.getWriteDataVariable());
                        analyzeDataFlowRelation(destColumn, sourceNames, EffectType.update, null);
                }
                if (stmt.getWriteDataLiteral() != null) {
                        List<TParseTreeNode> constants = new ArrayList<TParseTreeNode>();
                        constants.add(stmt.getWriteDataLiteral());
                        analyzeConstantDataFlowRelation(destColumn, constants, EffectType.update, null);
                }
        }

        /**
         * READTEXT table.column text_ptr offset size [HOLDLOCK] (Mantis #4607): the
         * column is read into the client stream; model the output as the statement's
         * result set with the read column so the read is visible in the lineage.
         */
        private void analyzeMssqlReadTextStmt(TMssqlReadText stmt) {
                TObjectName columnRef = stmt.getSourceColumnName();
                if (columnRef == null || columnRef.getSourceTable() == null) {
                        return;
                }
                Table tableModel = modelFactory.createTable(columnRef.getSourceTable());
                if (tableModel == null) {
                        return;
                }
                TableColumn sourceColumn = modelFactory.createTableColumn(tableModel, columnRef, false);
                if (sourceColumn == null) {
                        return;
                }
                ResultSet resultSet = modelFactory.createResultSet(stmt, true);
                ResultColumn resultColumn = modelFactory.createResultColumn(resultSet, columnRef);
                if (resultColumn == null) {
                        return;
                }
                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(EffectType.select);
                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                relation.addSource(new TableColumnRelationshipElement(sourceColumn));
        }

        /**
         * The write target of an UPDATETEXT/WRITETEXT statement: the model column of
         * the fused table.column reference, or null when the statement carries no
         * table-qualified column.
         */
        private TableColumn createTextPtrTargetColumn(TTable targetTable, TObjectName columnRef) {
                if (targetTable == null || columnRef == null) {
                        return null;
                }
                Table tableModel = modelFactory.createTable(targetTable);
                if (tableModel == null) {
                        return null;
                }
                return modelFactory.createTableColumn(tableModel, columnRef, false);
        }

        private void analyzeMssqlExecute(TMssqlExecute executeStmt) {
                if (executeStmt.getModuleName() != null) {
                        TObjectName module = executeStmt.getModuleName();
                        if(module.toString().toLowerCase(Locale.ROOT).endsWith("sp_rename")) {
                                String oldTableName = SQLUtil.trimColumnStringQuote(executeStmt.getParameters().getExecParameter(0).toString());        
                                Table oldNameTableModel = modelFactory.createTableByName(oldTableName, true);
                                List<String> oldTableNames = SQLUtil.parseNames(oldNameTableModel.getName());
                                TObjectName oldStarColumn = DlineageUtil.syntheticStarName();
                                TableColumn oldTableStarColumn = modelFactory.createTableColumn(oldNameTableModel, oldStarColumn, true);
                                
                                String newTableName = SQLUtil.trimColumnStringQuote(executeStmt.getParameters().getExecParameter(1).toString());
                                List<String> newTableNames = SQLUtil.parseNames(newTableName);
                                if (oldTableNames.size() > newTableNames.size()) {
                                        for (int i = oldTableNames.size() - newTableNames.size() - 1; i >= 0; i--) {
                                                newTableName = (oldTableNames.get(i) + ".") + newTableName;
                                        }
                                }

                                Table newNameTableModel = modelFactory.createTableByName(newTableName, true);
                                TObjectName newStarColumn = DlineageUtil.syntheticStarName();
                                TableColumn newTableStarColumn = modelFactory.createTableColumn(newNameTableModel, newStarColumn, true);
                                
                                Process process = modelFactory.createProcess(executeStmt);
                                newNameTableModel.addProcess(process);
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.rename_table);
                                relation.setTarget(new TableColumnRelationshipElement(newTableStarColumn));
                                relation.addSource(new TableColumnRelationshipElement(oldTableStarColumn));
                                relation.setProcess(process);
                                
                                if ((oldNameTableModel.isCreateTable() || oldNameTableModel.hasSQLEnv())) {
                                        oldTableStarColumn.setShowStar(false);
                                        relation.setShowStarRelation(false);
                                }

                                if ((newNameTableModel.isCreateTable() || newNameTableModel.hasSQLEnv())) {
                                        newTableStarColumn.setShowStar(false);
                                        relation.setShowStarRelation(false);
                                }
                        }
                        else if(module.toString().toLowerCase(Locale.ROOT).endsWith("sp_executesql")) {
                                String sql = SQLUtil.trimColumnStringQuote(executeStmt.getParameters().getExecParameter(0).toString());
                                if(sql.startsWith("N")) {
                                        sql =  SQLUtil.trimColumnStringQuote(sql.substring(1));
                                }
                                executeDynamicSql(sql);
                        }
                        else {
                                // sp_execute_external_script runs an R / Python / Java / ONNX script
                                // in-database (SQL Server 2016+ Machine Learning Services). Its
                                // @input_data_1 parameter is a SQL string literal whose SELECT reads
                                // real tables to build the InputDataSet the script consumes. Recover
                                // that source-table -> result-set lineage instead of dropping it
                                // (MantisBT #4606). This runs IN ADDITION to the generic call-edge
                                // handling below, so the call to sp_execute_external_script is still
                                // recorded.
                                if (option.isAnalyzeDynamicSql()
                                                && isSpExecuteExternalScript(module)) {
                                        analyzeExternalScriptInputData(executeStmt);
                                }
                                int argumentSize = executeStmt.getParameters() == null ? 0 : executeStmt.getParameters().size();
                                analyzeProcedureDefinition(nameAliasKey(module,
                                                argumentSize <= 0 ? null : RoutineAliases.countIfOverloads(argumentSize, option.getVendor())));
                                Procedure procedure = modelFactory.createProcedureByName(module, executeStmt.getParameters() == null ? 0 : executeStmt.getParameters().size());
                                String procedureParent = getProcedureParentName(executeStmt);
                                if (procedureParent != null) {
                                        Procedure caller = getEnclosingProcedure(executeStmt);
                                        if (caller != null) {
                                                CallRelationship callRelation = modelFactory.createCallRelation();
                                                callRelation.setCallObject(executeStmt);
                                                callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                callRelation.addSource(new ProcedureRelationshipElement(procedure));
                                                if(isBuiltInFunctionName(module) || isKeyword(module)){
                                                        callRelation.setBuiltIn(true);
                                                }
                                        }
                                }

                                if (awaitsDefinition(procedure)) {
                                        if (!deferredExecuteBindings.containsKey(executeStmt)) {
                                                deferredExecuteBindings.put(executeStmt, new DeferredExecuteBinding(procedure,
                                                                CallSiteState.capture(stmtStack, modelManager),
                                                                new ArrayList<TCustomSqlStatement>(analysisPath)));
                                        }
                                } else {
                                        bindExecuteArguments(executeStmt, procedure);
                                }
                        }
                }
        }

        /** Binds each argument of an EXEC to the formal it passes, in both directions for an OUTPUT formal. */
        private void bindExecuteArguments(TMssqlExecute executeStmt, Procedure procedure) {
                if (procedure.getArguments() == null) {
                        return;
                }
                TObjectName module = executeStmt.getModuleName();
                for (int i = 0; i < procedure.getArguments().size(); i++) {
                        Argument argument = procedure.getArguments().get(i);
                        Variable variable = modelFactory.createVariable(procedure, argument.getName(), false);
                        if (variable != null) {
                                if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                        Transform transform = new Transform();
                                        transform.setType(Transform.FUNCTION);
                                        transform.setCode(module);
                                        compositeBindingColumn(variable).setTransform(transform);
                                }
                                Process process = modelFactory.createProcess(executeStmt);
                                variable.addProcess(process);
                                analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), executeStmt, argument.getName(), i, process);
                        }
                }
        }

        /**
         * True when an EXEC's callee is only the name it was called by: no definition has been analyzed for it, so it
         * has no formals to bind. A call to a routine that a later unit defines is one (Mantis 4730): units are analyzed
         * one at a time and each knows only its own definitions. A definition with no parameters is not.
         */
        private static boolean awaitsDefinition(Procedure procedure) {
                return procedure.getProcedureObject() instanceof TObjectName
                                && (procedure.getArguments() == null || procedure.getArguments().isEmpty());
        }

        /**
         * Binds the arguments of the EXECs that called a routine before any definition of it was analyzed, once the unit
         * that defines the routine is analyzed. That definition takes over the model the call created, formals included
         * (see ModelFactory.createProcedure); each such call is then bound in the state it was analyzed in, as it is when
         * its unit comes right after the definition's. Calls whose routine no unit analyzed so far defines stay pending.
         */
        private void bindDeferredExecuteArguments() {
                Iterator<Map.Entry<TMssqlExecute, DeferredExecuteBinding>> pending = deferredExecuteBindings.entrySet().iterator();
                while (pending.hasNext()) {
                        Map.Entry<TMssqlExecute, DeferredExecuteBinding> entry = pending.next();
                        DeferredExecuteBinding deferred = entry.getValue();
                        if (awaitsDefinition(deferred.callee)) {
                                continue;
                        }
                        pending.remove();
                        CallSiteState current = CallSiteState.capture(stmtStack, modelManager);
                        deferred.callSite.enter(stmtStack, modelManager);
                        int relationshipsBefore = modelManager.getRelations().length;
                        try {
                                bindExecuteArguments(entry.getKey(), deferred.callee);
                                attributeToEnclosingDynamicSite(deferred.path, relationshipsBefore);
                        } finally {
                                deferred.callSite.leave(stmtStack, modelManager);
                                current.restore(stmtStack);
                        }
                }
        }

        /**
         * Adds the relationships that a deferred binding just created to the dynamic SQL site whose text holds the call,
         * the innermost one on the call's analysis path, as they are when the call binds inside that site's analysis.
         * They count as the site's lineage, and are proven only when every relationship the site recorded is proven and the
         * site's own proof filter accepts them; anything short of that leaves them observed, never proven.
         */
        private void attributeToEnclosingDynamicSite(List<TCustomSqlStatement> path, int relationshipsBefore) {
                for (int i = path.size() - 1; i >= 0; i--) {
                        // a statement with a site of its own (an EXEC inside a variant's text) belongs to it; another statement
                        // of a variant's text, to that variant's site
                        Integer index = dynamicSiteIndexes.get(path.get(i));
                        if (index == null) {
                                index = dynamicInnerSiteIndexes.get(path.get(i));
                        }
                        if (index == null) {
                                continue;
                        }
                        DynamicSqlSite site = dynamicSqlSites.get(index);
                        List<Long> added = dynamicRelationshipIdsSince(relationshipsBefore, dynamicSqlSites.size());
                        if (added.isEmpty()) {
                                return;
                        }
                        boolean complete = site.isHoleCountExact() && site.getUnresolvedHoleCount() == 0;
                        boolean proven = complete && site.getStatus() == DynamicSqlSite.Status.RESOLVED
                                        && site.getUnprovenRelationshipCount() == 0
                                        && site.getProvenRelationshipIds().size() == site.getObservedRelationshipIds().size();
                        List<Long> addedProven = proven
                                        ? provenDynamicRelationshipIdsSince(relationshipsBefore, dynamicSqlSites.size())
                                        : Collections.<Long>emptyList();
                        int[] counts = classifyDynamicSiteLineage(relationshipsBefore, !complete);
                        List<Long> observedIds = new ArrayList<Long>(site.getObservedRelationshipIds());
                        observedIds.addAll(added);
                        List<Long> provenIds = new ArrayList<Long>(site.getProvenRelationshipIds());
                        provenIds.addAll(addedProven);
                        int unproven = site.getUnprovenRelationshipCount();
                        if (site.getStatus() == DynamicSqlSite.Status.PARTIAL) {
                                unproven += added.size() - addedProven.size();
                        }
                        dynamicSqlSites.set(index, new DynamicSqlSite(site.getKind(), site.getStatus(), site.getReason(),
                                        site.getStartPosition(), site.getEndPosition(),
                                        site.getResolvedRelationshipCount() + counts[0], site.getPartialRelationshipCount() + counts[1],
                                        unproven, site.getUnresolvedHoleCount(), site.isHoleCountExact(), site.getTrustMode(),
                                        observedIds, provenIds, site.getDiagnostic(), site.getUnresolvedFragments(),
                                        site.getMaterializedText(), site.isExecutionCertain()));
                        return;
                }
        }

        private static final class DeferredExecuteBinding {
                final Procedure callee;
                final CallSiteState callSite;
                /** The statements being analyzed when the call was, outermost first (analysisPath). */
                final List<TCustomSqlStatement> path;

                DeferredExecuteBinding(Procedure callee, CallSiteState callSite, List<TCustomSqlStatement> path) {
                        this.callee = callee;
                        this.callSite = callSite;
                        this.path = path;
                }
        }

        /**
         * The analysis state a statement is analyzed in and that the models its relationships create read: the statement
         * stack (local symbol scopes), the routine being analyzed, the unit (coordinates) and its current database and
         * schema, and the overload pool. A deferred relationship is built in the state of the statement it belongs to.
         */
        private static final class CallSiteState {
                final List<TCustomSqlStatement> stack;
                final TStoredProcedureSqlStatement routine;
                final String hash;
                final String database;
                final IdentifierInputForm databaseForm;
                final String schema;
                final IdentifierInputForm schemaForm;
                final TSQLEnv sqlEnv;
                final String defaultCatalog;
                final String defaultSchema;
                final Object poolScope;
                final String poolKey;

                @SuppressWarnings("deprecation")
                private CallSiteState(Stack<TCustomSqlStatement> stmtStack, ModelBindingManager modelManager) {
                        stack = new ArrayList<TCustomSqlStatement>(stmtStack);
                        routine = ModelBindingManager.getGlobalProcedure();
                        hash = ModelBindingManager.getGlobalHash();
                        database = ModelBindingManager.getGlobalDatabase();
                        databaseForm = ModelBindingManager.getGlobalDatabaseForm();
                        schema = ModelBindingManager.getGlobalSchema();
                        schemaForm = ModelBindingManager.getGlobalSchemaForm();
                        sqlEnv = ModelBindingManager.getGlobalSQLEnv();
                        defaultCatalog = sqlEnv == null ? null : sqlEnv.getDefaultCatalogName();
                        defaultSchema = sqlEnv == null ? null : sqlEnv.getDefaultSchemaName();
                        poolScope = modelManager.peekPoolScope();
                        poolKey = modelManager.peekIdentityScope();
                }

                static CallSiteState capture(Stack<TCustomSqlStatement> stmtStack, ModelBindingManager modelManager) {
                        return new CallSiteState(stmtStack, modelManager);
                }

                /** Makes this state current; {@link #leave} undoes what only entering adds (the overload pool). */
                void enter(Stack<TCustomSqlStatement> stmtStack, ModelBindingManager modelManager) {
                        restore(stmtStack);
                        modelManager.pushIdentityScope(poolKey, poolScope);
                }

                void leave(Stack<TCustomSqlStatement> stmtStack, ModelBindingManager modelManager) {
                        if (poolKey != null || poolScope != null) {
                                modelManager.popIdentityScope();
                        }
                }

                /** Makes this state current, the overload pool apart. */
                void restore(Stack<TCustomSqlStatement> stmtStack) {
                        stmtStack.clear();
                        stmtStack.addAll(stack);
                        ModelBindingManager.restoreGlobalProcedure(routine);
                        if (hash != null) {
                                ModelBindingManager.setGlobalHash(hash);
                        } else {
                                ModelBindingManager.removeGlobalHash();
                        }
                        if (database != null) {
                                ModelBindingManager.setGlobalDatabase(database, databaseForm);
                        } else {
                                ModelBindingManager.removeGlobalDatabase();
                        }
                        if (schema != null) {
                                ModelBindingManager.setGlobalSchema(schema, schemaForm);
                        } else {
                                ModelBindingManager.removeGlobalSchema();
                        }
                        if (sqlEnv != null) {
                                ModelBindingManager.setGlobalSQLEnv(sqlEnv);
                                sqlEnv.setDefaultCatalogName(defaultCatalog);
                                sqlEnv.setDefaultSchemaName(defaultSchema);
                        } else {
                                ModelBindingManager.removeGlobalSQLEnv();
                        }
                }
        }

        private void analyzeDropTableStmt(TDropTableSqlStatement stmt) {
                TTable dropTable = stmt.getTargetTable();
                if(dropTable == null) {
                        return;
                }
                Table tableModel = modelManager.getTableByName(DlineageUtil.getTableIdentityKey(dropTable.getTableName().toString()));
                if(tableModel!=null) {
                        modelManager.dropTable(tableModel);
                }
                
                if(option.getAnalyzeMode() == AnalyzeMode.crud) {
                        tableModel = modelFactory.createTable(dropTable);
                        CrudRelationship crudRelationship = modelFactory.createCrudRelation();
                        crudRelationship.setTarget(new TableRelationshipElement(tableModel));
                        crudRelationship.setEffectType(EffectType.drop_table);
                }
        }
        
        private void analyzeTruncateTableStmt(TTruncateStatement stmt) {
                if(option.getAnalyzeMode() == AnalyzeMode.crud) {
                        TObjectName table = stmt.getTableName();
                        Table tableModel = modelFactory.createTableByName(table);
                        CrudRelationship crudRelationship = modelFactory.createCrudRelation();
                        crudRelationship.setTarget(new TableRelationshipElement(tableModel));
                        crudRelationship.setEffectType(EffectType.truncate_table);
                }
        }

        private void analyzeCallStmt(TCallStatement callStmt) {
                if (callStmt.getRoutineExpr() != null && callStmt.getRoutineExpr().getFunctionCall() != null) {

                        TFunctionCall functionCall = callStmt.getRoutineExpr().getFunctionCall();
                        Procedure callee = modelManager.getProcedure(callAliasKey(functionCall));
                        if (callee == null && analyzeProcedureDefinition(callAliasKey(functionCall))) {
                                callee = modelManager.getProcedure(callAliasKey(functionCall));
                        }
                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("analyzeCallStmt.call", functionCall.getFunctionName(), callee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf(functionCall)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.PROCEDURE);
                        if (callee != null) {
                                String procedureParent = getProcedureParentName(callStmt);
                                if (procedureParent != null) {
                                        Procedure caller = getEnclosingProcedure(callStmt);
                                        if (caller != null) {
                                                CallRelationship callRelation = modelFactory.createCallRelation();
                                                callRelation.setCallObject(callStmt);
                                                callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                callRelation.addSource(new ProcedureRelationshipElement(callee));
                                                if (isBuiltInFunctionName(functionCall.getFunctionName())
                                                                || isKeyword(functionCall.getFunctionName())) {
                                                        callRelation.setBuiltIn(true);
                                                }
                                        }
                                }
                                if (callee.getArguments() != null) {
                                        for (int i = 0; i < callee.getArguments().size(); i++) {
                                                Argument argument = callee.getArguments().get(i);
                                                Variable variable = resolveFormalVariable(callee, argument);
                                                if (variable != null) {
                                                        if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                                                Transform transform = new Transform();
                                                                transform.setType(Transform.FUNCTION);
                                                                transform.setCode(functionCall);
                                                                compositeBindingColumn(variable).setTransform(transform);
                                                        }
                                                        Process process = modelFactory.createProcess(callStmt);
                                                        variable.addProcess(process);
                                                        analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), functionCall, i,
                                                                        process);
                                                }
                                        }
                                }
                        } else {
                                Function function = (Function) createFunction(functionCall);
                                String procedureParent = getProcedureParentName(callStmt);
                                if (procedureParent != null) {
                                        Procedure caller = getEnclosingProcedure(callStmt);
                                        if (caller != null) {
                                                CallRelationship callRelation = modelFactory.createCallRelation();
                                                callRelation.setCallObject(callStmt);
                                                callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                callRelation.addSource(new FunctionRelationshipElement(function));
                                                if (isBuiltInFunctionName(functionCall.getFunctionName())
                                                                || isKeyword(functionCall.getFunctionName())) {
                                                        callRelation.setBuiltIn(true);
                                                }
                                        }
                                }
                        }
                }
                else if (callStmt.getRoutineName() != null) {
                        TObjectName function = callStmt.getRoutineName();
                        RoutineAliasKey functionKey = nameAliasKey(function, null);
                        Procedure callee = modelManager.getProcedure(functionKey);
                        if (callee == null && analyzeProcedureDefinition(functionKey)) {
                                callee = modelManager.getProcedure(functionKey);
                        }
                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("analyzeCallStmt.name", function, callee, new Integer[] {null}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.PROCEDURE);
                        if (callee != null) {
                                String procedureParent = getProcedureParentName(callStmt);
                                if (procedureParent != null) {
                                        Procedure caller = getEnclosingProcedure(callStmt);
                                        if (caller != null) {
                                                CallRelationship callRelation = modelFactory.createCallRelation();
                                                callRelation.setCallObject(callStmt);
                                                callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                callRelation.addSource(new ProcedureRelationshipElement(callee));
                                                if (isBuiltInFunctionName(function)
                                                                || isKeyword(function)) {
                                                        callRelation.setBuiltIn(true);
                                                }
                                        }
                                }
                                if (callee.getArguments() != null) {
                                        for (int i = 0; i < callee.getArguments().size(); i++) {
                                                Argument argument = callee.getArguments().get(i);
                                                Variable variable = resolveFormalVariable(callee, argument);
                                                if (variable != null) {
                                                        if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                                                Transform transform = new Transform();
                                                                transform.setType(Transform.FUNCTION);
                                                                transform.setCode(callStmt);
                                                                compositeBindingColumn(variable).setTransform(transform);
                                                        }
                                                        Process process = modelFactory.createProcess(callStmt);
                                                        variable.addProcess(process);
                                                        analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), callStmt, i,
                                                                        process);
                                                }
                                        }
                                }
                        }
                }
        }

        /**
         * DB2's CALL node is {@link TDb2CallStmt} (a sibling of {@link TCallStatement},
         * not a subclass), so the generic call dispatch never reaches it. Resolve its
         * caller/callee and emit the call relationship exactly as the
         * {@link #analyzeCallStmt} getRoutineName path does, using the DB2 accessors
         * getProcedureName()/getParameters().
         */
        private void analyzeDb2CallStmt(TDb2CallStmt callStmt) {
                if (callStmt.getProcedureName() == null) {
                        return;
                }
                TObjectName function = callStmt.getProcedureName();
                // DB2 supports procedure overloading by arity, so overloadable procedures
                // register under a "name(argCount)" key (see RoutineAliases.argumentCount).
                // Resolve by name+argCount first to bind the correct overload, then fall
                // back to the plain name for the single-definition / non-overloaded case.
                RoutineAliasKey nameKey = nameAliasKey(function, null);
                String count = callStmt.getParameters() == null ? null
                                : RoutineAliases.countIfOverloads(callStmt.getParameters().size(), ModelBindingManager.getGlobalVendor());
                RoutineAliasKey countKey = nameKey == null || count == null ? nameKey : nameKey.withSignature(count);
                Procedure callee = modelManager.getProcedure(countKey);
                if (callee == null && countKey != nameKey) {
                        callee = modelManager.getProcedure(nameKey);
                }
                if (callee == null && analyzeProcedureDefinition(countKey)) {
                        callee = modelManager.getProcedure(countKey);
                }
                if (callee == null && analyzeProcedureDefinition(nameKey)) {
                        callee = modelManager.getProcedure(nameKey);
                }
                if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("analyzeDb2CallStmt", function, callee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineDeclaration.callsCounted(ModelBindingManager.getGlobalVendor()) ? Integer.valueOf(callStmt.getParameters() == null ? 0 : callStmt.getParameters().size()) : null, null}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.PROCEDURE);
                if (callee != null) {
                        String procedureParent = getProcedureParentName(callStmt);
                        if (procedureParent != null) {
                                Procedure caller = getEnclosingProcedure(callStmt);
                                if (caller != null) {
                                        CallRelationship callRelation = modelFactory.createCallRelation();
                                        callRelation.setCallObject(callStmt);
                                        callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                        callRelation.addSource(new ProcedureRelationshipElement(callee));
                                        if (isBuiltInFunctionName(function) || isKeyword(function)) {
                                                callRelation.setBuiltIn(true);
                                        }
                                }
                        }
                        if (callee.getArguments() != null) {
                                for (int i = 0; i < callee.getArguments().size(); i++) {
                                        Argument argument = callee.getArguments().get(i);
                                        Variable variable = resolveFormalVariable(callee, argument);
                                        if (variable != null) {
                                                if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                                        Transform transform = new Transform();
                                                        transform.setType(Transform.FUNCTION);
                                                        transform.setCode(callStmt);
                                                        compositeBindingColumn(variable).setTransform(transform);
                                                }
                                                Process process = modelFactory.createProcess(callStmt);
                                                variable.addProcess(process);
                                                analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), callStmt, i,
                                                                process);
                                        }
                                }
                        }
                }
        }

        private boolean analyzeCustomFunctionCall(TFunctionCall functionCall) {
                Procedure callee = modelManager.getProcedure(callAliasKey(functionCall));
                if(callee == null && analyzeProcedureDefinition(callAliasKey(functionCall))) {
                        callee = modelManager.getProcedure(callAliasKey(functionCall));
                }
                if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("analyzeCustomFunctionCall", functionCall.getFunctionName(), callee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf(functionCall)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.FUNCTION);
                if (callee != null) {
                        String procedureParent = getProcedureParentName(stmtStack.peek());
                        if (procedureParent != null) {
                                Procedure caller = getEnclosingProcedure(stmtStack.peek());
                                if (caller != null) {
                                        CallRelationship callRelation = modelFactory.createCallRelation();
                                        callRelation.setCallObject(functionCall);
                                        callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                        callRelation.addSource(new ProcedureRelationshipElement(callee));
                                        if(isBuiltInFunctionName(functionCall.getFunctionName()) || isKeyword(functionCall.getFunctionName())){
                                                callRelation.setBuiltIn(true);
                                        }
                                }
                        }
                        if (callee.getArguments() != null) {
                                for (int i = 0; i < callee.getArguments().size(); i++) {
                                        Argument argument = callee.getArguments().get(i);
                                        Variable variable = resolveFormalVariable(callee, argument);
                                        if(variable!=null) {
                                                if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                                        Transform transform = new Transform();
                                                        transform.setType(Transform.FUNCTION);
                                                        transform.setCode(functionCall);
                                                        compositeBindingColumn(variable).setTransform(transform);
                                                }
                                                Process process = modelFactory.createProcess(functionCall);
                                                variable.addProcess(process);
                                                analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), functionCall, i, process);
                                        }
                                }
                        }
                        return true;
                }
                return false;
        }

        /** Resolve raw Oracle names within their declared scope, before legacy display-name aliases. */
        private Procedure resolveOracleRoutineCall(TBasicStmt site, TObjectName name, TFunctionCall call) {
                List<String> parts = SQLUtil.parseNames(name.toString());
                TStoredProcedureSqlStatement enclosing = oracleRoutineParent(site);
                OraclePackage currentPackage = ModelBindingManager.getGlobalOraclePackage();
                Procedure found = null;
                int bestScope = Integer.MIN_VALUE;
                boolean ambiguous = false;
                Set<Procedure> seen = Collections.newSetFromMap(new IdentityHashMap<Procedure, Boolean>());
                for (TStoredProcedureSqlStatement declaration : modelManager.getProcedures()) {
                        Object model = modelManager.getModel(declaration);
                        if (!(model instanceof Procedure) || getProcedureName(declaration) == null) continue;
                        Procedure candidate = (Procedure) model;
                        if (!seen.add(candidate)) continue;
                        OraclePackage owner = candidate.getParentPackage();
                        String declaredName = getProcedureName(declaration).toString();
                        int scope = 0;
                        TStoredProcedureSqlStatement parent = declaration.getParentStmt() == null ? null
                                        : oracleRoutineParent(declaration.getParentStmt());
                        if (parent != null && !(parent instanceof TPlsqlCreatePackage)) {
                                // A nested routine shadows a package member only inside its declaring scope.
                                TStoredProcedureSqlStatement visible = enclosing;
                                int depth = 0;
                                while (visible != null && visible != parent) {
                                        visible = visible.getParentStmt() == null ? null : oracleRoutineParent(visible.getParentStmt());
                                        depth++;
                                }
                                if (visible == null || parts.size() != 1) continue;
                                scope = Integer.MAX_VALUE - depth;
                        } else if (owner != null) {
                                if (parts.size() == 1) {
                                        if (owner != currentPackage) continue;
                                        scope = 1;
                                } else {
                                        TObjectName packageName = getProcedureName((TStoredProcedureSqlStatement) owner.getProcedureObject());
                                        String qualifier = owner == currentPackage && parts.size() == 2
                                                        ? packageName.getObjectString() : packageName.toString();
                                        declaredName = qualifier + "." + declaredName;
                                }
                        } else if (parts.size() == 1 && SQLUtil.parseNames(declaredName).size() > 1) {
                                // Preserve the legacy unique standalone-name fallback when the script
                                // omits its schema. Exact and lexical-scope matches take precedence.
                                declaredName = getProcedureName(declaration).getObjectString();
                                scope = -1;
                        }
                        if (!sameOracleRoutineName(name.toString(), declaredName)
                                        || !acceptsOracleArguments(declaration, call)) continue;
                        if (scope > bestScope) {
                                found = candidate;
                                bestScope = scope;
                                ambiguous = false;
                        } else if (scope == bestScope && found != candidate) {
                                ambiguous = true;
                        }
                }
                if (found != null) return ambiguous ? null : found;
                // Standalone definitions can appear later in the script. Use their raw AST names,
                // not the display-normalized map key, and keep the existing lazy body analysis.
                TStoredProcedureSqlStatement definition = uniqueOracleDefinition(procedureDDLAliases.values(), parts, name, call);
                if (definition != null) {
                        // The definition is standalone even when its caller is a package member.
                        OraclePackage savedPackage = ModelBindingManager.getGlobalOraclePackage();
                        TStoredProcedureSqlStatement savedProcedure = ModelBindingManager.getGlobalProcedure();
                        try {
                                ModelBindingManager.removeGlobalOraclePackage();
                                analyzeCustomSqlStmt(definition);
                        } finally {
                                ModelBindingManager.setGlobalOraclePackage(savedPackage);
                                ModelBindingManager.setGlobalProcedure(savedProcedure);
                        }
                        Object model = modelManager.getModel(definition);
                        if (model instanceof Procedure) return (Procedure) model;
                }
                return null;
        }

        /** The one standalone definition that matches an Oracle call, or null (none, or two different ones). */
        private TStoredProcedureSqlStatement uniqueOracleDefinition(Collection<TCustomSqlStatement> definitions,
                        List<String> parts, TObjectName name, TFunctionCall call) {
                TStoredProcedureSqlStatement definition = null;
                for (TCustomSqlStatement statement : definitions) {
                        if (!(statement instanceof TStoredProcedureSqlStatement)) continue;
                        TStoredProcedureSqlStatement candidate = (TStoredProcedureSqlStatement) statement;
                        if (candidate instanceof TPlsqlCreatePackage || getProcedureName(candidate) == null) continue;
                        String candidateName = parts.size() == 1 ? getProcedureName(candidate).getObjectString()
                                        : getProcedureName(candidate).toString();
                        if (sameOracleRoutineName(name.toString(), candidateName)
                                        && acceptsOracleArguments(candidate, call)) {
                                if (definition != null && definition != candidate) return null;
                                definition = candidate;
                        }
                }
                return definition;
        }

        private boolean sameOracleRoutineName(String left, String right) {
                List<String> a = SQLUtil.parseNames(left);
                List<String> b = SQLUtil.parseNames(right);
                if (a.size() != b.size()) return false;
                for (int i = 0; i < a.size(); i++) {
                        if (!DlineageUtil.sameName(ESQLDataObjectType.dotProcedure, a.get(i), b.get(i))) return false;
                }
                return true;
        }

        private boolean acceptsOracleArguments(TStoredProcedureSqlStatement declaration, TFunctionCall call) {
                int count = call == null || call.getArgs() == null ? 0 : call.getArgs().size();
                TParameterDeclarationList parameters = declaration.getParameterDeclarations();
                if (parameters == null) return count == 0;
                if (count > parameters.size()) return false;
                int matched = 0;
                for (int i = 0; i < parameters.size(); i++) {
                        TParameterDeclaration parameter = parameters.getParameterDeclarationItem(i);
                        if (oracleArgumentIndex(call, parameter.getParameterName(), i) >= 0) matched++;
                        else if (parameter.getDefaultValue() == null) return false;
                }
                return matched == count;
        }

        private int oracleArgumentIndex(TFunctionCall call, TObjectName formalName, int position) {
                if (call == null || call.getArgs() == null) return -1;
                for (int i = 0; i < call.getArgs().size(); i++) {
                        TExpression actual = call.getArgs().getExpression(i);
                        if (actual.getExpressionType() == EExpressionType.ref_arrow_t) {
                                if (formalName != null && actual.getLeftOperand() != null
                                                && DlineageUtil.sameName(ESQLDataObjectType.dotColumn,
                                                formalName.toString(), actual.getLeftOperand().toString())) return i;
                        } else if (i == position) return i;
                }
                return -1;
        }

        private RelationshipElement<?> oracleCallCaller(TBasicStmt site) {
                if (option.getVendor() == EDbVendor.dbvoracle) {
                        TStoredProcedureSqlStatement parent = oracleRoutineParent(site);
                        Procedure model = modelManager.getRoutineModel(parent);
                        if (model != null) return new ProcedureRelationshipElement(model);
                        if (parent == null) {
                                // An anonymous block is a real process, not a fabricated stored procedure.
                                return new ProcessRelationshipElement(modelFactory.createProcess(DlineageUtil.getTopStmt(site)));
                        }
                }
                Procedure caller = getEnclosingProcedure(site);
                return caller == null ? null : new ProcedureRelationshipElement(caller);
        }

        private TStoredProcedureSqlStatement oracleRoutineParent(TCustomSqlStatement site) {
                TStoredProcedureSqlStatement parent = getProcedureParent(site);
                while (parent != null && getProcedureName(parent) == null) {
                        TCustomSqlStatement outer = parent.getParentStmt();
                        parent = outer == null ? null : getProcedureParent(outer);
                }
                return parent;
        }

        private void analyzeOracleBasicStmt(TBasicStmt stmt) {
                if (stmt.getExpr() == null) return;
                TFunctionCall call = stmt.getExpr().getFunctionCall();
                TObjectName name = call == null ? stmt.getExpr().getObjectOperand() : call.getFunctionName();
                if (call == null && (option.getVendor() != EDbVendor.dbvoracle
                                || stmt.getExpr().getExpressionType() != EExpressionType.simple_object_name_t
                                || name == null)) return;
                if (call != null) recordDbmsSqlSiteIfParseCall(stmt, call);
                TParseTreeNode callObject = call == null ? name : call;
                Procedure callee;
                if (option.getVendor() == EDbVendor.dbvoracle) {
                        callee = resolveOracleRoutineCall(stmt, name, call);
                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("resolveOracleRoutineCall", name, callee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf(call)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.ROUTINE);
                } else {
                        RoutineAliasKey callKey = callAliasKey(call);
                        callee = modelManager.getProcedure(callKey);
                        if (callee == null && analyzeProcedureDefinition(callKey)) {
                                callee = modelManager.getProcedure(callKey);
                        }
                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("analyzeOracleBasicStmt", call.getFunctionName(), callee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf(call)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.ROUTINE);
                }
                RelationshipElement<?> source;
                if (callee != null) {
                        source = new ProcedureRelationshipElement(callee);
                } else {
                        Object function = call == null ? modelFactory.createFunction(name) : createFunction(call);
                        if (!(function instanceof Function)) return;
                        source = new FunctionRelationshipElement((Function) function);
                }
                RelationshipElement<?> caller = oracleCallCaller(stmt);
                if (caller != null) {
                        CallRelationship relation = modelFactory.createCallRelation();
                        relation.setCallObject(callObject);
                        relation.setTarget(caller);
                        relation.addSource(source);
                        if (functionChecker.isOraclePredefinedPackageFunction(name.toString())
                                        || isBuiltInFunctionName(name) || isKeyword(name)) relation.setBuiltIn(true);
                }
                if (callee != null && call != null) {
                        OraclePackage owner = callee.getParentPackage();
                        if (option.getVendor() == EDbVendor.dbvoracle && owner != null
                                        && !accessedStatements.contains(callee.getProcedureObject())) {
                                List<Pair<TBasicStmt, Procedure>> pending = pendingOracleCallArguments.get(owner);
                                if (pending == null) {
                                        pending = new ArrayList<Pair<TBasicStmt, Procedure>>();
                                        pendingOracleCallArguments.put(owner, pending);
                                }
                                pending.add(new Pair<TBasicStmt, Procedure>(stmt, callee));
                        } else {
                                analyzeOracleCallArguments(callee, call);
                        }
                }
        }

        private void analyzeOracleCallArguments(Procedure callee, TFunctionCall call) {
                if (callee.getArguments() == null) return;
                for (int i = 0; i < callee.getArguments().size(); i++) {
                        Argument argument = callee.getArguments().get(i);
                        int actualIndex = option.getVendor() == EDbVendor.dbvoracle
                                        ? oracleArgumentIndex(call, argument.getParameterObject().getParameterName(), i) : i;
                        if (actualIndex < 0) continue;
                        Variable variable = resolveFormalVariable(callee, argument);
                        if (variable == null) continue;
                        if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                Transform transform = new Transform();
                                transform.setType(Transform.FUNCTION);
                                transform.setCode(call);
                                compositeBindingColumn(variable).setTransform(transform);
                        }
                        Process process = modelFactory.createProcess(call);
                        variable.addProcess(process);
                        analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), call, actualIndex, process);
                }
        }

        private boolean isOracleBasicCall(TFunctionCall call) {
                return option.getVendor() == EDbVendor.dbvoracle && !stmtStack.isEmpty()
                                && stmtStack.peek() instanceof TBasicStmt
                                && ((TBasicStmt) stmtStack.peek()).getExpr().getFunctionCall() == call;
        }

        private void analyzeMssqlIfElseStmt(TMssqlIfElse ifStmt) {
                if (ifStmt.getCondition() != null) {
                        columnsInExpr visitor = new columnsInExpr();
                        ifStmt.getCondition().inOrderTraverse(visitor);
                        List<TParseTreeNode> functions = visitor.getFunctions();

                        if (functions != null && !functions.isEmpty()) {
                                for (int i = 0; i < functions.size(); i++) {
                                        if (!(functions.get(i) instanceof TFunctionCall))
                                                continue;
                                        TFunctionCall functionCall = (TFunctionCall) functions.get(i);
                                        Procedure callee = modelManager.getProcedure(callAliasKey(functionCall));
                                        if(callee == null && analyzeProcedureDefinition(callAliasKey(functionCall))) {
                                                callee = modelManager.getProcedure(callAliasKey(functionCall));
                                        }
                                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("analyzeMssqlIfElseStmt", functionCall.getFunctionName(), callee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf(functionCall)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.FUNCTION);
                                        if (callee != null) {
                                                String procedureParent = getProcedureParentName(ifStmt);
                                                if (procedureParent != null) {
                                                        Procedure caller = getEnclosingProcedure(ifStmt);
                                                        if (caller != null) {
                                                                CallRelationship callRelation = modelFactory.createCallRelation();
                                                                callRelation.setCallObject(functionCall);
                                                                callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                                callRelation.addSource(new ProcedureRelationshipElement(callee));
                                                                if (isBuiltInFunctionName(functionCall.getFunctionName()) || isKeyword(functionCall.getFunctionName())) {
                                                                        callRelation.setBuiltIn(true);
                                                                }
                                                        }
                                                }
                                                if (callee.getArguments() != null) {
                                                        for (int j = 0; j < callee.getArguments().size(); j++) {
                                                                Argument argument = callee.getArguments().get(j);
                                                                Variable variable = resolveFormalVariable(callee, argument);
                                                                if(variable!=null) {
                                                                        if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                                                                Transform transform = new Transform();
                                                                                transform.setType(Transform.FUNCTION);
                                                                                transform.setCode(functionCall);
                                                                                compositeBindingColumn(variable).setTransform(transform);
                                                                        }
                                                                        Process process = modelFactory.createProcess(functionCall);
                                                                        variable.addProcess(process);
                                                                        analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), functionCall, j, process);
                                                                }
                                                        }
                                                }
                                        } else {
                                                Object functionModel = createFunction(functionCall);
                                                if (!(functionModel instanceof Function)) {
                                                        continue;
                                                }
                                                Function function = (Function) functionModel;
                                                String procedureParent = getProcedureParentName(ifStmt);
                                                if (procedureParent != null) {
                                                        Procedure caller = getEnclosingProcedure(ifStmt);
                                                        if (caller != null) {
                                                                CallRelationship callRelation = modelFactory.createCallRelation();
                                                                callRelation.setCallObject(functionCall);
                                                                callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                                callRelation.addSource(new FunctionRelationshipElement(function));
                                                                if (isBuiltInFunctionName(functionCall.getFunctionName()) || isKeyword(functionCall.getFunctionName())) {
                                                                        callRelation.setBuiltIn(true);
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }

                if(ifStmt.getStmt()!=null) {
                        analyzeCustomSqlStmt(ifStmt.getStmt());
                }
        
                if (ifStmt.getElseStmt() != null) {
                        analyzeCustomSqlStmt(ifStmt.getElseStmt());
                }
        }
        
        private void analyzeIfStmt(TIfStmt ifStmt) {
                if (ifStmt.getCondition() != null) {
                        columnsInExpr visitor = new columnsInExpr();
                        ifStmt.getCondition().inOrderTraverse(visitor);
                        List<TParseTreeNode> functions = visitor.getFunctions();

                        if (functions != null && !functions.isEmpty()) {
                                for (int i = 0; i < functions.size(); i++) {
                                        if (!(functions.get(i) instanceof TFunctionCall))
                                                continue;
                                        TFunctionCall functionCall = (TFunctionCall) functions.get(i);
                                        Procedure callee = modelManager.getProcedure(callAliasKey(functionCall));
                                        if(callee == null && analyzeProcedureDefinition(callAliasKey(functionCall))) {
                                                callee = modelManager.getProcedure(callAliasKey(functionCall));
                                        }
                                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("analyzeIfStmt", functionCall.getFunctionName(), callee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf(functionCall)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.FUNCTION);
                                        if (callee != null) {
                                                String procedureParent = getProcedureParentName(ifStmt);
                                                if (procedureParent != null) {
                                                        Procedure caller = getEnclosingProcedure(ifStmt);
                                                        if (caller != null) {
                                                                CallRelationship callRelation = modelFactory.createCallRelation();
                                                                callRelation.setCallObject(functionCall);
                                                                callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                                callRelation.addSource(new ProcedureRelationshipElement(callee));
                                                                if (isBuiltInFunctionName(functionCall.getFunctionName()) || isKeyword(functionCall.getFunctionName())) {
                                                                        callRelation.setBuiltIn(true);
                                                                }
                                                        }
                                                }
                                                if (callee.getArguments() != null) {
                                                        for (int j = 0; j < callee.getArguments().size(); j++) {
                                                                Argument argument = callee.getArguments().get(j);
                                                                Variable variable = resolveFormalVariable(callee, argument);
                                                                if(variable!=null) {
                                                                        if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                                                                Transform transform = new Transform();
                                                                                transform.setType(Transform.FUNCTION);
                                                                                transform.setCode(functionCall);
                                                                                compositeBindingColumn(variable).setTransform(transform);
                                                                        }
                                                                        Process process = modelFactory.createProcess(functionCall);
                                                                        variable.addProcess(process);
                                                                        analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), functionCall, j, process);
                                                                }
                                                        }
                                                }
                                        } else {
                                                Object functionModel = createFunction(functionCall);
                                                if (!(functionModel instanceof Function)) {
                                                        continue;
                                                }
                                                Function function = (Function) functionModel;
                                                String procedureParent = getProcedureParentName(ifStmt);
                                                if (procedureParent != null) {
                                                        Procedure caller = getEnclosingProcedure(ifStmt);
                                                        if (caller != null) {
                                                                CallRelationship callRelation = modelFactory.createCallRelation();
                                                                callRelation.setCallObject(functionCall);
                                                                callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                                callRelation.addSource(new FunctionRelationshipElement(function));
                                                                if (isBuiltInFunctionName(functionCall.getFunctionName()) || isKeyword(functionCall.getFunctionName())) {
                                                                        callRelation.setBuiltIn(true);
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }

                if (ifStmt.getThenStatements() != null) {
                        for (int i = 0; i < ifStmt.getThenStatements().size(); ++i) {
                                analyzeCustomSqlStmt(ifStmt.getThenStatements().get(i));
                                ResultSet returnResult = modelFactory.createResultSet(ifStmt.getThenStatements().get(i), false);
                                if(returnResult!=null){
                                        for(ResultColumn resultColumn: returnResult.getColumns()){
                                                analyzeFilterCondition(resultColumn, ifStmt.getCondition(), null, null, EffectType.function);
                                        }
                                }
                        }
                }

                if (ifStmt.getElseifStatements() != null) {
                        for (int i = 0; i < ifStmt.getElseifStatements().size(); ++i) {
                                analyzeCustomSqlStmt(ifStmt.getElseifStatements().get(i));
                        }
                }

                if (ifStmt.getElseStatements() != null) {
                        for (int i = 0; i < ifStmt.getElseStatements().size(); ++i) {
                                analyzeCustomSqlStmt(ifStmt.getElseStatements().get(i));
                        }
                }
        }

        private void analyzeElsIfStmt(TElsifStmt elsIfStmt) {
                if (elsIfStmt.getCondition() != null) {
                        columnsInExpr visitor = new columnsInExpr();
                        elsIfStmt.getCondition().inOrderTraverse(visitor);
                        List<TParseTreeNode> functions = visitor.getFunctions();

                        if (functions != null && !functions.isEmpty()) {
                                for (int i = 0; i < functions.size(); i++) {
                                        if (!(functions.get(i) instanceof TFunctionCall))
                                                continue;
                                        TFunctionCall functionCall = (TFunctionCall) functions.get(i);
                                        Procedure callee = modelManager.getProcedure(callAliasKey(functionCall));
                                        if(callee == null && analyzeProcedureDefinition(callAliasKey(functionCall))) {
                                                callee = modelManager.getProcedure(callAliasKey(functionCall));
                                        }
                                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("analyzeElsIfStmt", functionCall.getFunctionName(), callee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf(functionCall)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.FUNCTION);
                                        if (callee != null) {
                                                String procedureParent = getProcedureParentName(elsIfStmt);
                                                if (procedureParent != null) {
                                                        Procedure caller = getEnclosingProcedure(elsIfStmt);
                                                        if (caller != null) {
                                                                CallRelationship callRelation = modelFactory.createCallRelation();
                                                                callRelation.setCallObject(functionCall);
                                                                callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                                callRelation.addSource(new ProcedureRelationshipElement(callee));
                                                                if(isBuiltInFunctionName(functionCall.getFunctionName()) || isKeyword(functionCall.getFunctionName())){
                                                                        callRelation.setBuiltIn(true);
                                                                }
                                                        }
                                                }
                                                if (callee.getArguments() != null) {
                                                        for (int j = 0; j < callee.getArguments().size(); j++) {
                                                                Argument argument = callee.getArguments().get(j);
                                                                Variable variable = resolveFormalVariable(callee, argument);
                                                                if(variable!=null) {
                                                                        if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                                                                Transform transform = new Transform();
                                                                                transform.setType(Transform.FUNCTION);
                                                                                transform.setCode(functionCall);
                                                                                compositeBindingColumn(variable).setTransform(transform);
                                                                        }
                                                                        Process process = modelFactory.createProcess(functionCall);
                                                                        variable.addProcess(process);
                                                                        analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), functionCall, j, process);
                                                                }
                                                        }
                                                }
                                        } else {
                                                Function function = (Function)createFunction(functionCall);
                                                String procedureParent = getProcedureParentName(elsIfStmt);
                                                if (procedureParent != null) {
                                                        Procedure caller = getEnclosingProcedure(elsIfStmt);
                                                        if (caller != null) {
                                                                CallRelationship callRelation = modelFactory.createCallRelation();
                                                                callRelation.setCallObject(functionCall);
                                                                callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                                callRelation.addSource(new FunctionRelationshipElement(function));
                                                                if(isBuiltInFunctionName(functionCall.getFunctionName()) || isKeyword(functionCall.getFunctionName())){
                                                                        callRelation.setBuiltIn(true);
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }

                if (elsIfStmt.getThenStatements() != null) {
                        for (int i = 0; i < elsIfStmt.getThenStatements().size(); ++i) {
                                ResultSet returnResult = modelFactory.createResultSet(elsIfStmt.getThenStatements().get(i), false);
                                if (returnResult != null) {
                                        for (ResultColumn resultColumn : returnResult.getColumns()) {
                                                analyzeFilterCondition(resultColumn, elsIfStmt.getCondition(), null, null, EffectType.function);
                                        }
                                }
                                analyzeCustomSqlStmt(elsIfStmt.getThenStatements().get(i));
                        }
                }
        }

        private void analyzeCloneTableStmt(TCreateTableSqlStatement stmt) {
                if (stmt.getCloneSourceTable() != null) {
                        Table sourceTable = modelFactory.createTableByName(stmt.getCloneSourceTable());
                        Table cloneTable = modelFactory.createTableByName(stmt.getTableName());
                        // Clone creates the target. Parse fact, set regardless of source
                        // resolution (the gated setFromDDL below stays as-is). See
                        // dlineage-authoritative-endpoint-classification.md.
                        cloneTable.setCreatedInSql(true);
                        cloneTable.setEndpointIntroduction(EndpointIntroduction.CLONE_TABLE);
                        Process process = modelFactory.createProcess(stmt);
                        cloneTable.addProcess(process);

                        if (sourceTable.isDetermined()) {
                                for (int k = 0; k < sourceTable.getColumns().size(); k++) {
                                        TableColumn sourceColumn = sourceTable.getColumns().get(k);
                                        TObjectName objectName = new TObjectName();
                                        objectName.setString(sourceColumn.getName());
                                        TableColumn tableColumn = modelFactory.createTableColumn(cloneTable, objectName, true);
                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                        dataflowRelation.setEffectType(EffectType.clone_table);
                                        dataflowRelation
                                                        .addSource(new TableColumnRelationshipElement(sourceColumn));
                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                        dataflowRelation.setProcess(process);
                                }
                                cloneTable.setDetermined(true);
                                cloneTable.setFromDDL(true);
                        } else {
                                TObjectName sourceName = DlineageUtil.syntheticStarName();
                                TableColumn sourceTableColumn = modelFactory.createTableColumn(sourceTable, sourceName, false);
                                TObjectName targetName = DlineageUtil.syntheticStarName();
                                TableColumn targetTableColumn = modelFactory.createTableColumn(cloneTable, targetName, false);
                                if(sourceTableColumn!=null && targetTableColumn!=null) {
                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                        dataflowRelation.setEffectType(EffectType.clone_table);
                                        dataflowRelation
                                                        .addSource(new TableColumnRelationshipElement(sourceTableColumn));
                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(targetTableColumn));
                                        dataflowRelation.setProcess(process);
                                }
                        }
                }
        }

        private void analyzeCloneDatabaseStmt(TCreateDatabaseSqlStatement stmt) {
                if (stmt.getCloneSourceDb() != null) {
                        Database sourceDatabase = modelFactory.createDatabase(stmt.getCloneSourceDb());
                        Database cloneDatabase = modelFactory.createDatabase(stmt.getDatabaseName());
                        Process process = modelFactory.createProcess(stmt);
                        cloneDatabase.addProcess(process);
                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                        relation.setEffectType(EffectType.clone_database);
                        relation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(cloneDatabase.getRelationRows()));
                        relation.addSource(
                                        new RelationRowsRelationshipElement<TableRelationRows>(sourceDatabase.getRelationRows()));
                        relation.setProcess(process);
                }
        }

        private void analyzeCloneSchemaStmt(TCreateSchemaSqlStatement stmt) {
                if (stmt.getCloneSourceSchema() != null) {
                        Schema sourceSchema = modelFactory.createSchema(stmt.getCloneSourceSchema());
                        Schema cloneSchema = modelFactory.createSchema(stmt.getSchemaName());
                        Process process = modelFactory.createProcess(stmt);
                        cloneSchema.addProcess(process);
                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                        relation.setEffectType(EffectType.clone_schema);
                        relation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(cloneSchema.getRelationRows()));
                        relation.addSource(new RelationRowsRelationshipElement<TableRelationRows>(sourceSchema.getRelationRows()));
                        relation.setProcess(process);
                }
        }

        /**
         * Record one dynamic-SQL site. Span is the statement extent (1-based, end-exclusive), tagged with
         * the per-statement file hash, mirroring the {@link ErrorInfo} position convention. When the
         * {@code reportDynamicSqlSitesAsErrors} option is on, non-RESOLVED sites are also mirrored into an
         * {@link ErrorInfo} so legacy {@code getErrorMessages()} consumers can see them.
         */
        private void recordDynamicSqlSite(TCustomSqlStatement stmt, DynamicSqlSite.Kind kind,
                        DynamicSqlSite.Status status, String reason) {
                recordDynamicSqlSite(stmt, kind, status, reason, 0, 0);
        }

        private void recordDynamicSqlSite(TCustomSqlStatement stmt, DynamicSqlSite.Kind kind,
                        DynamicSqlSite.Status status, String reason, int resolvedCount, int partialCount) {
                DynamicSqlTrustMode trustMode = option == null ? DynamicSqlTrustMode.LEGACY
                                : option.getDynamicSqlTrustMode();
                // This compatibility overload has no fragment provenance. Never turn
                // that absence into an exact zero; callers with evidence use the full
                // overload below.
                recordDynamicSqlSite(stmt, kind, status, reason, resolvedCount, partialCount,
                                0, -1, false, trustMode);
        }

        private void recordDynamicSqlSite(TCustomSqlStatement stmt, DynamicSqlSite.Kind kind,
                        DynamicSqlSite.Status status, String reason, int resolvedCount, int partialCount,
                        int unprovenCount, int unresolvedHoleCount,
                        boolean holeCountExact, DynamicSqlTrustMode trustMode) {
                recordDynamicSqlSite(stmt, kind, status, reason, resolvedCount, partialCount,
                                unprovenCount, unresolvedHoleCount, holeCountExact, trustMode,
                                -1, -1, null);
        }

        private void recordDynamicSqlSite(TCustomSqlStatement stmt, DynamicSqlSite.Kind kind,
                        DynamicSqlSite.Status status, String reason, int resolvedCount, int partialCount,
                        int unprovenCount, int unresolvedHoleCount,
                        boolean holeCountExact, DynamicSqlTrustMode trustMode,
                        int relationshipsBefore, int nestedSitesBefore) {
                recordDynamicSqlSite(stmt, kind, status, reason, resolvedCount, partialCount,
                                unprovenCount, unresolvedHoleCount, holeCountExact, trustMode,
                                relationshipsBefore, nestedSitesBefore, null);
        }

        private void recordDynamicSqlSite(TCustomSqlStatement stmt, DynamicSqlSite.Kind kind,
                        DynamicSqlSite.Status status, String reason, int resolvedCount, int partialCount,
                        int unprovenCount, int unresolvedHoleCount,
                        boolean holeCountExact, DynamicSqlTrustMode trustMode,
                        int relationshipsBefore, int nestedSitesBefore,
                        List<Long> explicitlyProvenRelationshipIds) {
                recordDynamicSqlSite(stmt, kind, status, reason, resolvedCount, partialCount,
                                unprovenCount, unresolvedHoleCount, holeCountExact, trustMode,
                                relationshipsBefore, nestedSitesBefore,
                                explicitlyProvenRelationshipIds, null);
        }

        private void recordDynamicSqlSite(TCustomSqlStatement stmt, DynamicSqlSite.Kind kind,
                        DynamicSqlSite.Status status, String reason, int resolvedCount, int partialCount,
                        int unprovenCount, int unresolvedHoleCount,
                        boolean holeCountExact, DynamicSqlTrustMode trustMode,
                        int relationshipsBefore, int nestedSitesBefore,
                        List<Long> explicitlyProvenRelationshipIds, String diagnostic) {
                recordDynamicSqlSite(stmt, kind, status, reason, resolvedCount, partialCount,
                                unprovenCount, unresolvedHoleCount, holeCountExact, trustMode,
                                relationshipsBefore, nestedSitesBefore,
                                explicitlyProvenRelationshipIds, diagnostic,
                                Collections.<UnresolvedFragment>emptyList(), null);
        }

        /**
         * An opaque site the evaluator could not turn into analyzable text: UNRESOLVED with
         * the argument-shape reason, carrying whatever hole evidence the evaluator gathered
         * on the way (the variable that stopped the fold, its assignment, its span).
         */
        private void recordUnresolvedDynamicSqlSite(TCustomSqlStatement stmt, TMssqlExecute executeStmt,
                        DynamicSqlSite.Kind kind) {
                gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite evaluated =
                                evaluatedDynamicSqlFor(stmt);
                DynamicHoleEvidence holeEvidence = dynamicHoleEvidence(evaluated);
                String provenNull = provenNullReasonOf(stmt);
                // every binding that reached the site, not only the one whose variant stands for it
                gudusoft.gsqlparser.dlineage.dynamicsql.BindingSource bindings = gudusoft.gsqlparser.dlineage.dynamicsql.BindingSource.NONE;
                boolean certain = evaluated == null || evaluated.executionCertain;
                for (gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite candidate : selectVariants(stmt)) {
                        bindings = bindings.getKind() == gudusoft.gsqlparser.dlineage.dynamicsql.BindingSource.Kind.NONE
                                        ? candidate.bindingSource : bindings.alsoAt(candidate.bindingSource);
                        certain &= candidate.executionCertain;
                }
                recordDynamicSqlSite(stmt, kind, DynamicSqlSite.Status.UNRESOLVED,
                                provenNull != null ? "the dynamic SQL is NULL and runs nothing: " + provenNull
                                                : evaluated != null && evaluated.sqlText == null
                                                                && evaluated.bindingSource.getKind() != gudusoft.gsqlparser.dlineage.dynamicsql.BindingSource.Kind.NONE
                                                                ? "the evaluation with the bound parameters gives no SQL text"
                                                                                + (evaluated.reason == null ? "" : ": " + evaluated.reason)
                                                                : dynamicReasonOf(executeStmt),
                                0, 0, 0, holeEvidence.count, holeEvidence.exact, option.getDynamicSqlTrustMode(),
                                -1, -1, null, evaluated == null ? null
                                                : gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.joinNotes(
                                                                evaluated.executionNote, bindings.getDescription()),
                                holeEvidence.fragments,
                                holeEvidence.materializedText, certain);
        }

        private void recordDynamicSqlSite(TCustomSqlStatement stmt, DynamicSqlSite.Kind kind,
                        DynamicSqlSite.Status status, String reason, int resolvedCount, int partialCount,
                        int unprovenCount, int unresolvedHoleCount,
                        boolean holeCountExact, DynamicSqlTrustMode trustMode,
                        int relationshipsBefore, int nestedSitesBefore,
                        List<Long> explicitlyProvenRelationshipIds, String diagnostic,
                        List<UnresolvedFragment> unresolvedFragments, String materializedText) {
                recordDynamicSqlSite(stmt, kind, status, reason, resolvedCount, partialCount, unprovenCount,
                                unresolvedHoleCount, holeCountExact, trustMode, relationshipsBefore, nestedSitesBefore,
                                explicitlyProvenRelationshipIds, diagnostic, unresolvedFragments, materializedText, true);
        }

        private void recordDynamicSqlSite(TCustomSqlStatement stmt, DynamicSqlSite.Kind kind,
                        DynamicSqlSite.Status status, String reason, int resolvedCount, int partialCount,
                        int unprovenCount, int unresolvedHoleCount,
                        boolean holeCountExact, DynamicSqlTrustMode trustMode,
                        int relationshipsBefore, int nestedSitesBefore,
                        List<Long> explicitlyProvenRelationshipIds, String diagnostic,
                        List<UnresolvedFragment> unresolvedFragments, String materializedText,
                        boolean executionCertain) {
                if (stmt == null || stmt.getStartToken() == null || stmt.getEndToken() == null) {
                        return;
                }
                diagnostic = withDynamicEvaluationNotes(diagnostic);
                List<Long> observedRelationshipIds = dynamicRelationshipIdsSince(
                                relationshipsBefore, nestedSitesBefore);
                List<Long> provenRelationshipIds = Collections.emptyList();
                if (explicitlyProvenRelationshipIds != null) {
                        LinkedHashSet<Long> observed = new LinkedHashSet<Long>(observedRelationshipIds);
                        provenRelationshipIds = new ArrayList<Long>();
                        for (Long id : explicitlyProvenRelationshipIds) {
                                if (id != null && observed.contains(id)
                                                && !provenRelationshipIds.contains(id)) {
                                        provenRelationshipIds.add(id);
                                }
                        }
                } else if (status == DynamicSqlSite.Status.RESOLVED
                                && unprovenCount == 0
                                && holeCountExact && unresolvedHoleCount == 0) {
                        provenRelationshipIds = provenDynamicRelationshipIdsSince(
                                        relationshipsBefore, nestedSitesBefore);
                }
                Pair3<Long, Long, String> start = new Pair3<Long, Long, String>(stmt.getStartToken().lineNo,
                                stmt.getStartToken().columnNo, ModelBindingManager.getGlobalHash());
                Pair3<Long, Long, String> end;
                String[] segments = stmt.getEndToken().getAstext().split("\n", -1);
                if (segments.length == 1) {
                        end = new Pair3<Long, Long, String>(stmt.getEndToken().lineNo,
                                        stmt.getEndToken().columnNo + stmt.getEndToken().getAstext().length(),
                                        ModelBindingManager.getGlobalHash());
                } else {
                        end = new Pair3<Long, Long, String>(stmt.getEndToken().lineNo + segments.length - 1,
                                        (long) segments[segments.length - 1].length() + 1, ModelBindingManager.getGlobalHash());
                }
                dynamicSqlSites.add(new DynamicSqlSite(kind, status, reason, start, end,
                                resolvedCount, partialCount, unprovenCount,
                                unresolvedHoleCount, holeCountExact, trustMode,
                                observedRelationshipIds, provenRelationshipIds, diagnostic,
                                unresolvedFragments, materializedText, executionCertain));
                dynamicSiteIndexes.put(stmt, dynamicSqlSites.size() - 1);

                if (status != DynamicSqlSite.Status.RESOLVED && option != null
                                && option.isReportDynamicSqlSitesAsErrors()) {
                        ErrorInfo errorInfo = new ErrorInfo();
                        errorInfo.setErrorType(ErrorInfo.DYNAMIC_SQL_UNRESOLVED);
                        errorInfo.setErrorMessage(reason != null ? reason : "dynamic SQL not resolved");
                        errorInfo.setStartPosition(start);
                        errorInfo.setEndPosition(end);
                        errorInfo.fillInfo(this);
                        errorInfos.add(errorInfo);
                }
        }

        /**
         * Relationship IDs created by one dynamic site, excluding relationship
         * deltas already attributed to nested dynamic sites. The IDs match the
         * non-simple XML model emitted by this analyzer instance.
         */
        private List<Long> dynamicRelationshipIdsSince(int beforeCount, int nestedSitesBefore) {
                if (beforeCount < 0) {
                        return Collections.emptyList();
                }
                Set<Long> nested = new HashSet<Long>();
                if (nestedSitesBefore >= 0) {
                        for (int i = Math.min(nestedSitesBefore, dynamicSqlSites.size());
                                        i < dynamicSqlSites.size(); i++) {
                                nested.addAll(dynamicSqlSites.get(i).getObservedRelationshipIds());
                        }
                }
                Relationship[] relationships = modelManager.getRelations();
                List<Long> ids = new ArrayList<Long>();
                for (int i = Math.min(beforeCount, relationships.length);
                                i < relationships.length; i++) {
                        Relationship relationship = relationships[i];
                        if (relationship instanceof AbstractRelationship) {
                                Long id = Long.valueOf(((AbstractRelationship) relationship).getId());
                                if (!nested.contains(id)) {
                                        ids.add(id);
                                }
                        }
                }
                return ids;
        }

        /**
         * Per-edge proof filter for a complete materialization. Placeholder-tainted
         * relations and every downstream relation that consumes their target stay
         * observation-only; independent relations from the same site remain proven.
         */
        private List<Long> provenDynamicRelationshipIdsSince(
                        int beforeCount, int nestedSitesBefore) {
                List<Long> observedIds = dynamicRelationshipIdsSince(beforeCount, nestedSitesBefore);
                if (observedIds.isEmpty()) {
                        return observedIds;
                }
                Set<Long> observed = new HashSet<Long>(observedIds);
                Set<Long> nestedUnproven = new HashSet<Long>();
                if (nestedSitesBefore >= 0) {
                        for (int i = Math.min(nestedSitesBefore, dynamicSqlSites.size());
                                        i < dynamicSqlSites.size(); i++) {
                                DynamicSqlSite nestedSite = dynamicSqlSites.get(i);
                                nestedUnproven.addAll(nestedSite.getObservedRelationshipIds());
                                nestedUnproven.removeAll(nestedSite.getProvenRelationshipIds());
                        }
                }

                Set<Object> taintedElements = Collections.newSetFromMap(
                                new IdentityHashMap<Object, Boolean>());
                Set<Relationship> taintedRelationships = Collections.newSetFromMap(
                                new IdentityHashMap<Relationship, Boolean>());
                Relationship[] relationships = modelManager.getRelations();
                Map<Long, Relationship> relationshipsById = new HashMap<Long, Relationship>();
                for (Relationship relationship : relationships) {
                        if (!(relationship instanceof AbstractRelationship)) continue;
                        Long id = Long.valueOf(((AbstractRelationship) relationship).getId());
                        relationshipsById.put(id, relationship);
                        if (nestedUnproven.contains(id)) {
                                addDynamicTargetElement(taintedElements, relationship);
                        }
                }

                boolean changed;
                do {
                        changed = false;
                        for (Relationship relationship : relationships) {
                                if (!(relationship instanceof AbstractRelationship)
                                                || !observed.contains(Long.valueOf(
                                                                ((AbstractRelationship) relationship).getId()))
                                                || taintedRelationships.contains(relationship)) {
                                        continue;
                                }
                                if (hasUnresolvedDynamicEndpoint(relationship)
                                                || hasDynamicSourceElement(taintedElements, relationship)) {
                                        taintedRelationships.add(relationship);
                                        changed |= addDynamicTargetElement(taintedElements, relationship);
                                }
                        }
                } while (changed);

                List<Long> proven = new ArrayList<Long>();
                for (Long id : observedIds) {
                        Relationship relationship = relationshipsById.get(id);
                        if (relationship != null && !taintedRelationships.contains(relationship)) {
                                proven.add(id);
                        }
                }
                return proven;
        }

        private boolean hasDynamicSourceElement(Set<Object> elements, Relationship relationship) {
                if (relationship.getSources() == null) return false;
                for (Object value : relationship.getSources()) {
                        if (value instanceof RelationshipElement
                                        && elements.contains(((RelationshipElement<?>) value).getElement())) {
                                return true;
                        }
                }
                return false;
        }

        private boolean addDynamicTargetElement(Set<Object> elements, Relationship relationship) {
                if (relationship.getTarget() == null
                                || relationship.getTarget().getElement() == null) {
                        return false;
                }
                return elements.add(relationship.getTarget().getElement());
        }

        private boolean hasUnresolvedDynamicEndpoint(Relationship relationship) {
                if (hasPlaceholderSourceTable(relationship, false)) {
                        return true;
                }
                if (relationship.getSources() != null) {
                        for (Object value : relationship.getSources()) {
                                if (value instanceof RelationRowsRelationshipElement) {
                                        Object rows = ((RelationRowsRelationshipElement<?>) value).getElement();
                                        if (rows instanceof TableRelationRows
                                                        && isRuntimeObjectPlaceholder(
                                                                        ((TableRelationRows) rows).getHolder())) {
                                                return true;
                                        }
                                }
                        }
                }
                Object target = relationship.getTarget() == null
                                ? null : relationship.getTarget().getElement();
                if (target instanceof TableColumn) {
                        return isRuntimeObjectPlaceholder(((TableColumn) target).getTable());
                }
                return target instanceof TableRelationRows
                                && isRuntimeObjectPlaceholder(((TableRelationRows) target).getHolder());
        }

        private boolean isRuntimeObjectPlaceholder(Table table) {
                if (table == null || table.isPseudo()) return true;
                if (table.isVariable()) return false;
                String name = table.getName();
                return name != null && name.trim().startsWith("@");
        }

        /** Identity snapshot used only by SHADOW observability; it never drives removal. */
        private Set<Relationship> snapshotDynamicRelationships() {
                Set<Relationship> snapshot = Collections.newSetFromMap(
                                new IdentityHashMap<Relationship, Boolean>());
                Collections.addAll(snapshot, modelManager.getRelations());
                return snapshot;
        }

        /** Exact number of currently published relationships not present in {@code before}. */
        private int countNewDynamicRelationships(Set<Relationship> before) {
                if (before == null) {
                        return 0;
                }
                int count = 0;
                for (Relationship relation : modelManager.getRelations()) {
                        if (!before.contains(relation)) {
                                count++;
                        }
                }
                return count;
        }

        /**
         * One unresolved hole of a dynamic fold, located by CHARACTER SPAN in the analyzed text
         * rather than by its rendered spelling. Locating by text would over-mark: a hole rendering
         * as {@code SRC} also occurs inside the unrelated literal {@code SRC_COPY} in the same batch.
         *
         * <p>A hole here is always a fragment whose VALUE is unknown. An {@code INEXACT_TRANSFORM}
         * fragment is deliberately NOT one: there the evaluator did compute the value from literals
         * ({@code REPLACE(tmpl, '{SRC}', 'dbo.SalesOrders')}) and only its byte-exactness against
         * vendor runtime semantics is unproven. Treating it as a hole would brand every fully
         * template-resolved name a runtime template — the opposite of this feature's purpose.
         */
        private static final class FoldHole {
                /** Character span [start, end) in the analyzed text; start == end for a splice point. */
                final int start;
                final int end;
                FoldHole(int start, int end) {
                        this.start = start;
                        this.end = end;
                }

                /** True when this hole can affect any character of [from, to) — splice points included. */
                boolean touches(int from, int to) {
                        if (start == end) {
                                return from <= start && start <= to;
                        }
                        return start < to && end > from;
                }
        }

        /** Conservative fold-hole spelling: the unresolved {@code @variable} remnant a partial fold leaves behind. */
        private static final Pattern DYNAMIC_FOLD_PLACEHOLDER = Pattern.compile("@\\w+");

        /**
         * Depth of dynamic-fold inner analysis currently on the stack. Statements analyzed at
         * depth 0 are STATIC statements of the unit; their table references veto dynamic-template
         * marks on the same name (see {@link #applyStaticTemplateVetoes}), which is what makes the
         * shared-node contract independent of statement ORDER — a static reference after the fold
         * withdraws the mark exactly as one before the fold prevents it.
         */
        private int dynamicFoldDepth = 0;

        /** True once any endpoint of this analysis carries a dynamic-template mark. */
        private boolean anyDynamicTemplateMarked = false;

        /**
         * Name-registry keys of every table referenced by a STATIC statement after the first
         * template mark. A fold never marks (and a later collection unmarks) a name in this set.
         */
        private final Set<Object> staticTemplateVetoKeys = new HashSet<Object>();

        /** Statements already veto-walked (identity), so repeated re-analysis stays O(1). */
        private final Set<TCustomSqlStatement> staticVetoWalkedStmts =
                        Collections.newSetFromMap(new IdentityHashMap<TCustomSqlStatement, Boolean>());

        /**
         * Collects {@code stmt}'s static table references into the veto set and withdraws any
         * template mark already sitting on a node they share. Runs only at fold depth 0 and only
         * once a mark exists, so the common no-dynamic-SQL unit pays nothing.
         */
        private void applyStaticTemplateVetoes(TCustomSqlStatement stmt) {
                // Walk each statement object once: the veto keys accumulate, so a repeat walk of a
                // re-analyzed procedure body adds nothing but O(AST) cost per call.
                if (!staticVetoWalkedStmts.add(stmt)) {
                        return;
                }
                TemplateTableCollector collector = new TemplateTableCollector();
                try {
                        if (stmt instanceof TSelectSqlStatement) {
                                collector.preVisit((TSelectSqlStatement) stmt);
                        }
                        stmt.acceptChildren(collector);
                } catch (RuntimeException ex) {
                        // This is an enrichment-only walk over an error-recovered AST. Keep every
                        // static veto collected before the malformed slot, and never let a missing
                        // annotation discard the statement's real lineage.
                        logger.warn("Static template-veto walk was incomplete; keeping recovered lineage", ex);
                }
                for (TTable table : collector.tables) {
                        if (table.getSubquery() != null || table.getCTE() != null
                                        || table.getTableName() == null) {
                                continue;
                        }
                        vetoStaticTemplateName(table.getTableName().toString());
                }
                for (TObjectName intoTarget : collector.intoTargets) {
                        vetoStaticTemplateName(intoTarget.toString());
                }
        }

        /**
         * Records one static reference under the SAME name-registry keys the model-reuse lookups
         * use ({@code ModelFactory.createTableByName}), so the veto matches exactly the reuse that
         * creates a shared node.
         */
        private void vetoStaticTemplateName(String rawName) {
                if (SQLUtil.isEmpty(rawName)) {
                        return;
                }
                Object[] keys = { DlineageUtil.getTableIdentityKey(rawName),
                                DlineageUtil.getTableIdentityKeyWithDefaultSchema(rawName) };
                for (Object key : keys) {
                        if (key == null || (key instanceof String && SQLUtil.isEmpty((String) key))) {
                                continue;
                        }
                        staticTemplateVetoKeys.add(key);
                        Table bound = modelManager.getTableByName(key);
                        if (bound != null && bound.isDynamicTemplate()) {
                                bound.clearDynamicTemplate();
                        }
                }
        }

        /**
         * A delimited identifier whose ENTIRE content is an {@code @variable} remnant —
         * {@code [@S]} / {@code "@S"}, the shape a {@code '... [' + @S + '] ...'} splice folds to.
         * Deliberately anchored to the whole content: {@code [weird@name]} does NOT match, because
         * a delimited name that merely CONTAINS an {@code @} is an ordinary legal identifier.
         */
        private static final Pattern DYNAMIC_FOLD_DELIMITED_PLACEHOLDER =
                        Pattern.compile("\\[(@\\w+)\\]|\"(@\\w+)\"");

        /**
         * Identity snapshot of the endpoints that already existed before a dynamic fold was
         * analyzed, so {@link #markDynamicTemplateEndpoints} can restrict itself to the nodes
         * THIS fold introduced. Returns {@code null} when the fold cannot carry a hole, which is
         * the signal to skip marking entirely (and pay nothing on the fully-resolved path).
         */
        /**
         * The holes of the text an EXECUTE of PostgreSQL's format() analyzes (Mantis 4880): the parser puts PLACEHOLDER
         * where each %s of the template stands for a runtime argument. Rebuilt from the template, so a PLACEHOLDER the
         * template itself spells is no hole; none when the rebuilt text is not the analyzed one.
         */
        private static List<FoldHole> formatHoles(TExecuteSqlStatement stmt, String analyzedText) {
                TExpression call = stmt.getStmtString();
                if (call == null || call.getExpressionType() != EExpressionType.function_t || call.getFunctionCall() == null
                                || !call.toString().startsWith("format") || call.getFunctionCall().getArgs() == null
                                || call.getFunctionCall().getArgs().size() == 0) {
                        return Collections.emptyList();
                }
                String template = SQLUtil.trimColumnStringQuote(call.getFunctionCall().getArgs().getExpression(0).toString());
                List<FoldHole> holes = new ArrayList<FoldHole>();
                StringBuilder text = new StringBuilder();
                int percents = 0;
                for (int i = 0; i < template.length(); i++) {
                        if (template.startsWith("%s", i)) {
                                // the parser replaces every %s; only one after an odd run of % is a specifier (%% is a literal %)
                                if ((percents + 1) % 2 == 1) {
                                        holes.add(new FoldHole(text.length(), text.length() + "PLACEHOLDER".length()));
                                }
                                text.append("PLACEHOLDER");
                                i++;
                                percents = 0;
                        } else {
                                percents = template.charAt(i) == '%' ? percents + 1 : 0;
                                text.append(template.charAt(i));
                        }
                }
                return text.toString().equals(analyzedText) ? holes : Collections.<FoldHole>emptyList();
        }

        private Set<Table> snapshotTemplateCandidateTables(boolean foldMayCarryHoles) {
                if (!foldMayCarryHoles) {
                        return null;
                }
                Set<Table> snapshot = Collections.newSetFromMap(new IdentityHashMap<Table, Boolean>());
                snapshot.addAll(modelManager.getTablesByName());
                return snapshot;
        }

        /**
         * Exact hole spans for {@code analyzedText}, from the evaluator's fragment provenance.
         * Empty unless the site describes THIS text — spans taken from a different materialization
         * would point at arbitrary offsets of the string actually analyzed.
         */
        /** True when the site carries fragments that provably render its own text. */
        private static boolean hasCompleteFragmentProvenance(
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site) {
                if (site == null || site.sqlText == null || site.fragments.isEmpty()) {
                        return false;
                }
                StringBuilder rendered = new StringBuilder(site.sqlText.length());
                for (gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment f : site.fragments) {
                        rendered.append(f.text);
                }
                return rendered.toString().equals(site.sqlText);
        }

        /** True when any fragment of the site stands in for a value nobody knows. */
        private static boolean hasValueUnknownHole(
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site) {
                if (site == null) {
                        return false;
                }
                for (gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment f : site.fragments) {
                        if (!f.isLiteral() && f.valueUnknown) {
                                return true;
                        }
                }
                return false;
        }

        /**
         * Value-unknown hole spans of a site whose text IS the analyzed text. A hole whose value
         * the evaluator computed from literals ({@code SqlFragment.valueUnknown} false) is an
         * unproven RENDERING of a known name, not a runtime template, and yields no span.
         */
        private List<FoldHole> exactFoldHoles(
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site,
                        String analyzedText) {
                List<FoldHole> holes = new ArrayList<FoldHole>();
                if (site == null || site.sqlText == null || analyzedText == null
                                || !site.sqlText.equals(analyzedText)) {
                        return holes;
                }
                List<int[]> spans = gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlEdgeProof
                                .holeSpansOf(site);
                List<gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment> fragments =
                                gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlEdgeProof.holesOf(site);
                for (int i = 0; i < spans.size() && i < fragments.size(); i++) {
                        if (!fragments.get(i).valueUnknown) {
                                continue;
                        }
                        int[] span = spans.get(i);
                        holes.add(new FoldHole(span[0], span[1]));
                }
                return holes;
        }

        /**
         * Maps the site's hole positions into a DIFFERENT rendering of the same fold — the legacy
         * token fold renders a hole as the variable/function name ({@code [pre_UPPER]}) where the
         * evaluator renders {@code [pre_@X]} — by aligning the LITERAL fragments, which both
         * renderings share, against the analyzed text. The literals are matched twice, greedily
         * from the left and greedily from the right; only when both passes agree is the alignment
         * forced, and the gaps between matched literals are then provably the holes. Returns
         * {@code null} when alignment is ambiguous or impossible — the caller falls back to the
         * conservative tier rather than guess.
         */
        private List<FoldHole> alignedFoldHoles(
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site,
                        String analyzedText) {
                if (site == null || analyzedText == null) {
                        return null;
                }
                List<gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment> fragments = site.fragments;
                // A value-KNOWN hole's text IS its value (that is what valueUnknown=false means), so
                // it anchors the alignment exactly like a literal. Without this, a known hole
                // adjacent to an unknown one would smear "templated" across every segment the
                // combined gap touches — [' + UPPER(@D) + '].[dbo].[x] must report db, not
                // db|schema|name. If the legacy rendering of the known hole differs, the anchor
                // match fails and the alignment is refused rather than guessed.
                List<String> literals = new ArrayList<String>();
                for (gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment f : fragments) {
                        if (isAlignmentAnchor(f) && !f.text.isEmpty()) {
                                literals.add(f.text);
                        }
                }
                int n = literals.size();
                int[] posForward = new int[n];
                int cursor = 0;
                for (int i = 0; i < n; i++) {
                        int at = analyzedText.indexOf(literals.get(i), cursor);
                        if (at < 0) {
                                return null;
                        }
                        posForward[i] = at;
                        cursor = at + literals.get(i).length();
                }
                int[] posBackward = new int[n];
                cursor = analyzedText.length();
                for (int i = n - 1; i >= 0; i--) {
                        int at = analyzedText.lastIndexOf(literals.get(i), cursor - literals.get(i).length());
                        if (at < 0) {
                                return null;
                        }
                        posBackward[i] = at;
                        cursor = at;
                }
                for (int i = 0; i < n; i++) {
                        if (posForward[i] != posBackward[i]) {
                                return null;
                        }
                }
                // Walk the fragments, attributing each inter-literal gap to the hole fragments
                // between the anchors. A non-empty gap with no hole, or leftover text at either
                // end, means the analyzed text is not this fold — refuse.
                List<FoldHole> holes = new ArrayList<FoldHole>();
                int pos = 0;
                int literalIndex = 0;
                boolean pendingHole = false;
                for (gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment f : fragments) {
                        if (isAlignmentAnchor(f)) {
                                if (f.text.isEmpty()) {
                                        continue;
                                }
                                int at = posForward[literalIndex++];
                                if (at < pos) {
                                        return null;
                                }
                                if (at > pos && !pendingHole) {
                                        return null;
                                }
                                if (pendingHole) {
                                        holes.add(new FoldHole(pos, at));
                                }
                                pendingHole = false;
                                pos = at + f.text.length();
                        } else {
                                pendingHole = true;
                        }
                }
                if (pos < analyzedText.length() && !pendingHole) {
                        return null;
                }
                if (pendingHole) {
                        holes.add(new FoldHole(pos, analyzedText.length()));
                }
                return holes;
        }

        /** Literal fragments AND value-known holes anchor the alignment; only value-unknown holes gap. */
        private static boolean isAlignmentAnchor(gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment f) {
                return f.isLiteral() || !f.valueUnknown;
        }

        /**
         * Fallback for a legacy token fold that carries no fragment provenance: the unresolved
         * {@code @variable} remnants left in the text. Restricted to what is PROVABLE — a T-SQL
         * family dialect (where an undelimited leading {@code @} cannot begin a legal object name,
         * the same reasoning {@link #isPlaceholderNamedTable} relies on), and only occurrences
         * outside identifier delimiters and string literals. A bracketed {@code [weird@name]} is a
         * legal literal identifier even inside a folded batch, so it is deliberately not a hole
         * here; such a name is only marked when exact provenance says so.
         */
        private List<FoldHole> conservativeFoldHoles(String analyzedText) {
                List<FoldHole> holes = new ArrayList<FoldHole>();
                if (analyzedText == null || !Table.isTsqlFamilyVendor(option.getVendor())) {
                        return holes;
                }
                Matcher matcher = DYNAMIC_FOLD_PLACEHOLDER.matcher(analyzedText);
                while (matcher.find()) {
                        if (!isInsideDelimiterOrLiteral(analyzedText, matcher.start())) {
                                holes.add(new FoldHole(matcher.start(), matcher.end()));
                        }
                }
                Matcher delimited = DYNAMIC_FOLD_DELIMITED_PLACEHOLDER.matcher(analyzedText);
                while (delimited.find()) {
                        // The delimiters themselves are literal fold text; only the content is the hole,
                        // so a '#'/'@' that survives outside them still classifies the endpoint.
                        if (!isInsideDelimiterOrLiteral(analyzedText, delimited.start())) {
                                holes.add(new FoldHole(delimited.start() + 1, delimited.end() - 1));
                        }
                }
                return holes;
        }

        /** True when {@code index} sits inside a delimited identifier or a string literal. */
        private static boolean isInsideDelimiterOrLiteral(String text, int index) {
                boolean inBracket = false, inDoubleQuote = false, inSingleQuote = false;
                for (int i = 0; i < index && i < text.length(); i++) {
                        char c = text.charAt(i);
                        if (inBracket) {
                                if (c == ']') {
                                        inBracket = false;
                                }
                        } else if (inDoubleQuote) {
                                if (c == '"') {
                                        inDoubleQuote = false;
                                }
                        } else if (inSingleQuote) {
                                if (c == '\'') {
                                        inSingleQuote = false;
                                }
                        } else if (c == '[') {
                                inBracket = true;
                        } else if (c == '"') {
                                inDoubleQuote = true;
                        } else if (c == '\'') {
                                inSingleQuote = true;
                        }
                }
                return inBracket || inDoubleQuote || inSingleQuote;
        }

        /**
         * Land the placeholder verdict on the MODEL NODES a partially-folded dynamic site just
         * produced (docs/tmp/dynamic-template-endpoint-provenance.md): every endpoint whose
         * identifier OVERLAPS an unresolved hole is marked {@link EndpointKind#DYNAMIC_TEMPLATE}
         * and told WHICH name segments are templated, so a consumer never has to sniff {@code @}
         * out of a name — which it cannot do soundly, because the fold keeps the original
         * delimiters and {@code [weird@name]} is a legal literal identifier.
         *
         * <p>Overlap is decided on CHARACTER SPANS of this parse's own tokens against the hole
         * spans (exact tier) or the provable {@code @\w+} remnants (conservative tier) — never on
         * rendered-text coincidence, which marks unrelated literals that happen to contain a
         * hole's spelling.
         *
         * <p>Never marks outside a fold context ({@code before == null} short-circuits), and never
         * marks a plain endpoint that already existed before this fold — a static statement's
         * {@code dbo.[weird@name]} stays exactly what it was. <b>Known limitation:</b> when a
         * static statement and a folded statement name the SAME object, the model carries one
         * shared node; it is left unmarked, because marking it would make the static reference
         * wrong. Per-reference template provenance would be needed to state both facts.
         *
         * <p>Oracle {@code EXECUTE IMMEDIATE} / DBMS_SQL legacy folds splice a BARE identifier
         * ({@code '... FROM ' || p_tab}), indistinguishable from a real table name and carrying no
         * fragment provenance, so they are deliberately NOT marked rather than marked on a guess.
         */
        private void markDynamicTemplateEndpoints(Set<Table> before,
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site,
                        TGSqlParser analyzedParser) {
                if (before == null || analyzedParser == null || analyzedParser.sqlstatements == null) {
                        return;
                }
                markDynamicTemplateEndpoints(before, analyzedParser, dynamicFoldHoles(site, analyzedParser.sqltext));
        }

        /**
         * {@link #markDynamicTemplateEndpoints(Set, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite, TGSqlParser)}
         * for holes already known: the exact tier, when the analysis itself put each hole into the text
         * ({@link #formatHoles}, Mantis 4880).
         */
        private void markDynamicTemplateEndpoints(Set<Table> before, TGSqlParser analyzedParser, List<FoldHole> holes) {
                if (before == null || analyzedParser == null || analyzedParser.sqlstatements == null || holes.isEmpty()) {
                        return;
                }
                String analyzedText = analyzedParser.sqltext;
                TemplateTableCollector collector = new TemplateTableCollector();
                for (int i = 0; i < analyzedParser.sqlstatements.size(); i++) {
                        TCustomSqlStatement stmt = analyzedParser.sqlstatements.get(i);
                        if (stmt == null) {
                                continue;
                        }
                        try {
                                // acceptChildren does not preVisit the statement itself, so a top-level
                                // SELECT ... INTO <target> would lose its write endpoint.
                                if (stmt instanceof TSelectSqlStatement) {
                                        collector.preVisit((TSelectSqlStatement) stmt);
                                }
                                stmt.acceptChildren(collector);
                        } catch (RuntimeException ex) {
                                // A clean inner parse can still contain recovery shells. The collector is
                                // stateless, so keep endpoints reached before the bad slot and continue with
                                // later statements. A warning is intentional: marks for this site may be
                                // incomplete, but enrichment must never erase otherwise valid lineage.
                                logger.warn("Dynamic template endpoint walk was incomplete; keeping recovered lineage", ex);
                        }
                }
                // a name the fold also spells away from every hole is a real object, never a template (Codex review of
                // Mantis 4880: format('INSERT INTO %s SELECT c FROM PLACEHOLDER', t))
                for (TTable table : collector.tables) {
                        if (table.getSubquery() == null && table.getCTE() == null && table.getTableName() != null
                                        && !touchesHole(table.getTableName(), analyzedText, holes)) {
                                vetoStaticTemplateName(table.getTableName().toString());
                        }
                }
                for (TTable table : collector.tables) {
                        if (table.getSubquery() != null || table.getCTE() != null) {
                                continue;
                        }
                        markDynamicTemplateEndpoint(before, table.getTableName(),
                                        templateTableModelOf(table), analyzedText, holes);
                }
                for (TObjectName intoTarget : collector.intoTargets) {
                        // SELECT ... INTO targets are bound by NAME (ModelFactory.createTableByName),
                        // not against the parsed node, so they resolve through the name registry.
                        Table model = modelManager.getTableByName(
                                        DlineageUtil.getTableIdentityKey(intoTarget.toString()));
                        markDynamicTemplateEndpoint(before, intoTarget, model, analyzedText, holes);
                }
                for (TMssqlBulkInsert bulkInsert : collector.bulkInserts) {
                        // BULK INSERT (Mantis 4962): the target is bound by name like an INTO target. Its file
                        // was made a template path before the statement was analyzed (noteTemplatedLoadFiles).
                        TObjectName target = bulkInsert.getTableName();
                        if (target != null) {
                                markDynamicTemplateEndpoint(before, target,
                                                modelManager.getTableByName(DlineageUtil.getTableIdentityKey(target.toString())),
                                                analyzedText, holes);
                        }
                }
        }

        /**
         * The holes of a dynamic fold's analyzed text: from the site's exact provenance when it has it (none when every
         * part of the string is a known value), else from the conservative remnant scan of the legacy fold.
         */
        private List<FoldHole> dynamicFoldHoles(
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site, String analyzedText) {
                if (hasCompleteFragmentProvenance(site)) {
                        // Exact provenance is AUTHORITATIVE in both directions: zero value-unknown
                        // holes means every part of the string is a known value, so nothing here is
                        // runtime-templated and the conservative heuristic must NOT run — it would
                        // mark a legitimate literal-derived [@S].
                        if (!hasValueUnknownHole(site)) {
                                return Collections.emptyList();
                        }
                        if (site.sqlText.equals(analyzedText)) {
                                return exactFoldHoles(site, analyzedText);
                        }
                        // The analyzed text is the legacy token fold's rendering of the same
                        // fold; map the holes across via literal alignment, falling back to the
                        // conservative remnant scan when the alignment cannot be proven.
                        List<FoldHole> holes = alignedFoldHoles(site, analyzedText);
                        return holes != null ? holes : conservativeFoldHoles(analyzedText);
                }
                return conservativeFoldHoles(analyzedText);
        }

        /**
         * Notes, while a dynamic fold is analyzed, the file literals of its BULK INSERT statements that a hole reaches
         * inside the quotes: such a file is a runtime template, a path node of its own that no static reference of the
         * same text shares (Codex review of Mantis 4962 step 3), so it must be known before the statement is analyzed.
         * Returns the literals it noted, for {@link #forgetTemplatedLoadFiles}.
         */
        private List<TConstant> noteTemplatedLoadFiles(
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site,
                        TGSqlParser analyzedParser) {
                List<TConstant> added = new ArrayList<TConstant>();
                if (analyzedParser == null || analyzedParser.sqlstatements == null || analyzedParser.sqltext == null) {
                        return added;
                }
                TemplateTableCollector collector = new TemplateTableCollector();
                for (int i = 0; i < analyzedParser.sqlstatements.size(); i++) {
                        TCustomSqlStatement stmt = analyzedParser.sqlstatements.get(i);
                        if (stmt != null) {
                                try {
                                        // TMssqlBulkInsert.acceptChildren visits the statement itself too
                                        stmt.acceptChildren(collector);
                                } catch (RuntimeException ex) {
                                        logger.warn("Dynamic template endpoint walk was incomplete; keeping recovered lineage", ex);
                                }
                        }
                }
                if (collector.bulkInserts.isEmpty()) {
                        return added;
                }
                String analyzedText = analyzedParser.sqltext;
                List<FoldHole> holes = dynamicFoldHoles(site, analyzedText);
                for (TMssqlBulkInsert bulkInsert : collector.bulkInserts) {
                        TConstant file = bulkInsert.getDatafile();
                        if (file != null && literalContentTouched(file, analyzedText, holes) && !templatedLoadFiles.containsKey(file)) {
                                templatedLoadFiles.put(file, file);
                                added.add(file);
                        }
                }
                return added;
        }

        private void forgetTemplatedLoadFiles(List<TConstant> added) {
                for (TConstant file : added) {
                        templatedLoadFiles.remove(file);
                }
        }

        /** The file literals of the dynamic folds being analyzed that a hole reaches, by identity. */
        private final Map<TConstant, TConstant> templatedLoadFiles = new IdentityHashMap<TConstant, TConstant>();

        /** Whether a hole reaches any character inside the quotes of the string literal {@code file}. */
        private static boolean literalContentTouched(TConstant file, String analyzedText, List<FoldHole> holes) {
                if (holes.isEmpty() || file.getStartToken() == null || file.getEndToken() == null || file.toString() == null) {
                        return false;
                }
                String literal = file.toString().trim();
                int from = (int) file.getStartToken().offset;
                int to = (int) (file.getEndToken().offset + file.getEndToken().toString().length());
                if (literal.length() > 1 && (literal.charAt(0) == 'N' || literal.charAt(0) == 'n') && literal.charAt(1) == '\'') {
                        from++;
                }
                // the characters inside the quotes
                int contentFrom = from + 1;
                int contentTo = to - 1;
                if (from < 0 || contentTo < contentFrom || to > analyzedText.length()) {
                        return false;
                }
                for (FoldHole hole : holes) {
                        if (hole.touches(contentFrom, contentTo)) {
                                return true;
                        }
                }
                return false;
        }

        /** Collects the endpoint-bearing name nodes of an analyzed dynamic-fold parse. */
        private static final class TemplateTableCollector extends TParseTreeVisitor {
                final List<TTable> tables = new ArrayList<TTable>();
                final List<TObjectName> intoTargets = new ArrayList<TObjectName>();
                final List<TMssqlBulkInsert> bulkInserts = new ArrayList<TMssqlBulkInsert>();

                @Override
                public void preVisit(TTable table) {
                        if (table != null) {
                                tables.add(table);
                        }
                }

                @Override
                public void preVisit(TMssqlBulkInsert bulkInsert) {
                        if (bulkInsert != null) {
                                bulkInserts.add(bulkInsert);
                        }
                }

                @Override
                public void preVisit(TSelectSqlStatement select) {
                        if (select == null) {
                                return;
                        }
                        if (select.getIntoTableClause() != null
                                        && select.getIntoTableClause().getTableName() != null) {
                                intoTargets.add(select.getIntoTableClause().getTableName());
                        }
                        // T-SQL SELECT ... INTO <target> arrives as an INTO clause carrying an
                        // expression list, the same shape analyzeSelectIntoClause() reads.
                        TIntoClause intoClause = select.getIntoClause();
                        if (intoClause == null || intoClause.getExprList() == null) {
                                return;
                        }
                        for (int i = 0; i < intoClause.getExprList().size(); i++) {
                                TExpression expr = intoClause.getExprList().getExpression(i);
                                if (expr != null && expr.getObjectOperand() != null) {
                                        intoTargets.add(expr.getObjectOperand());
                                }
                        }
                }
        }

        /** Per-endpoint half of {@link #markDynamicTemplateEndpoints}: span overlap + part labelling. */
        private void markDynamicTemplateEndpoint(Set<Table> before, TObjectName tableName,
                        Table model, String analyzedText, List<FoldHole> holes) {
                if (tableName == null || model == null || tableName.getStartToken() == null
                                || tableName.getEndToken() == null) {
                        return;
                }
                int from = (int) tableName.getStartToken().offset;
                int to = (int) (tableName.getEndToken().offset
                                + tableName.getEndToken().toString().length());
                if (from < 0 || to <= from || to > analyzedText.length()) {
                        return;
                }
                List<int[]> segments = nameSegmentSpans(analyzedText, from, to);
                if (segments.isEmpty()) {
                        return;
                }
                int last = segments.size() - 1;
                StringBuilder parts = new StringBuilder();
                boolean identityTemplated = false;
                for (int i = 0; i < segments.size(); i++) {
                        int[] segment = segments.get(i);
                        boolean touched = false;
                        for (FoldHole hole : holes) {
                                if (!hole.touches(segment[0], segment[1])) {
                                        continue;
                                }
                                touched = true;
                                // The hole reaching the FIRST character of the object-name segment means the
                                // '#'/'@' prefix that would classify this endpoint as temp / table-variable is
                                // itself unknown runtime text ('INSERT INTO ' + @tab folds to a table named
                                // @tab, which really names a CATALOG object).
                                if (i == last
                                                && hole.touches(firstNameChar(analyzedText, segment),
                                                                firstNameChar(analyzedText, segment) + 1)) {
                                        identityTemplated = true;
                                }
                        }
                        if (!touched) {
                                continue;
                        }
                        String part = templatedPartLabel(i, last);
                        if (part == null) {
                                continue;
                        }
                        if (parts.length() > 0) {
                                parts.append('|');
                        }
                        parts.append(part);
                }
                if (parts.length() == 0) {
                        return;
                }
                if (model.hasSubquery() || model.isPseudo() || model.isVariable()) {
                        return;
                }
                // A plain endpoint that predates this fold is shared with a static reference; marking
                // it would make that reference wrong. An endpoint already known to be a template may
                // accumulate more segments from a second fold.
                if (before.contains(model) && !model.isDynamicTemplate()) {
                        return;
                }
                // The same contract, order-independent: a name a STATIC statement referenced at any
                // earlier point of the unit is never marked (see staticTemplateVetoKeys).
                if (staticTemplateVetoKeys.contains(DlineageUtil.getTableIdentityKey(tableName.toString()))
                                || staticTemplateVetoKeys.contains(
                                                DlineageUtil.getTableIdentityKeyWithDefaultSchema(tableName.toString()))) {
                        return;
                }
                model.markDynamicTemplate(parts.toString(), identityTemplated);
                anyDynamicTemplateMarked = true;
        }

        /** Whether a hole reaches any character of {@code name} in {@code analyzedText}; true when its span is unknown. */
        private static boolean touchesHole(TObjectName name, String analyzedText, List<FoldHole> holes) {
                if (name.getStartToken() == null || name.getEndToken() == null) {
                        return true;
                }
                int from = (int) name.getStartToken().offset;
                int to = (int) (name.getEndToken().offset + name.getEndToken().toString().length());
                if (from < 0 || to <= from || to > analyzedText.length()) {
                        return true;
                }
                for (FoldHole hole : holes) {
                        if (hole.touches(from, to)) {
                                return true;
                        }
                }
                return false;
        }

        /** Offset of a segment's first NAME character, skipping an opening identifier delimiter. */
        private static int firstNameChar(String text, int[] segment) {
                int i = segment[0];
                if (i < text.length()) {
                        char c = text.charAt(i);
                        if (c == '[' || c == '"' || c == '`') {
                                return i + 1;
                        }
                }
                return i;
        }

        /**
         * Splits the source span of a qualified name into one span per identifier segment, on the
         * dots that sit OUTSIDE identifier delimiters (so {@code [a.b].c} is two segments).
         */
        private static List<int[]> nameSegmentSpans(String text, int from, int to) {
                List<int[]> segments = new ArrayList<int[]>();
                int segmentStart = from;
                boolean inBracket = false, inDoubleQuote = false, inBacktick = false;
                for (int i = from; i < to; i++) {
                        char c = text.charAt(i);
                        if (inBracket) {
                                if (c == ']') {
                                        inBracket = false;
                                }
                        } else if (inDoubleQuote) {
                                if (c == '"') {
                                        inDoubleQuote = false;
                                }
                        } else if (inBacktick) {
                                if (c == '`') {
                                        inBacktick = false;
                                }
                        } else if (c == '[') {
                                inBracket = true;
                        } else if (c == '"') {
                                inDoubleQuote = true;
                        } else if (c == '`') {
                                inBacktick = true;
                        } else if (c == '.') {
                                segments.add(new int[] { segmentStart, i });
                                segmentStart = i + 1;
                        }
                }
                segments.add(new int[] { segmentStart, to });
                return segments;
        }

        /**
         * Outermost-first segment labels for a qualified name, counted from the RIGHT so a
         * 2-, 3- or 4-part name labels consistently. Anything deeper than server is unlabelled.
         */
        private String templatedPartLabel(int index, int lastIndex) {
                switch (lastIndex - index) {
                case 0:
                        return "name";
                case 1:
                        return "schema";
                case 2:
                        return "db";
                case 3:
                        return "server";
                default:
                        return null;
                }
        }

        /** The dlineage endpoint model bound to a parsed table, across the binding maps. */
        private Table templateTableModelOf(TTable table) {
                Object model = modelManager.getModel(table);
                if (!(model instanceof Table)) {
                        model = modelManager.getCreateModel(table);
                }
                if (!(model instanceof Table)) {
                        model = modelManager.getInsertModel(table);
                }
                if (!(model instanceof Table)) {
                        model = modelManager.getUpdateModel(table);
                }
                if (!(model instanceof Table)) {
                        model = modelManager.getMergeModel(table);
                }
                return model instanceof Table ? (Table) model : null;
        }

        /**
         * What a site can say about its holes. {@code exact} is true only when the evaluator
         * saw the site's argument: then {@code count == fragments.size()}, and
         * {@code materializedText} is the argument as far as it folded (holes rendered as
         * their placeholder text). Otherwise {@code count} is {@code -1} and the list is
         * empty - "not known", never an invented zero.
         */
        private static final class DynamicHoleEvidence {
                final int count;
                final boolean exact;
                final List<UnresolvedFragment> fragments;
                final String materializedText;

                DynamicHoleEvidence(int count, boolean exact, List<UnresolvedFragment> fragments,
                                String materializedText) {
                        this.count = count;
                        this.exact = exact;
                        this.fragments = fragments;
                        this.materializedText = materializedText;
                }
        }

        private static final DynamicHoleEvidence NO_HOLE_EVIDENCE = new DynamicHoleEvidence(-1, false,
                        Collections.<UnresolvedFragment>emptyList(), null);

        private DynamicHoleEvidence dynamicHoleEvidence(
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site) {
                if (site == null) {
                        return NO_HOLE_EVIDENCE;
                }
                if (!site.provenanceIncomplete) {
                        return new DynamicHoleEvidence(0, true, Collections.<UnresolvedFragment>emptyList(),
                                        site.sqlText);
                }
                if (site.fragments.isEmpty()) {
                        // The value did not reduce and the producer left no provenance (a channel
                        // without fragments, or a value that never touched a variable).
                        return new DynamicHoleEvidence(-1, false, Collections.<UnresolvedFragment>emptyList(),
                                        site.sqlText);
                }
                List<UnresolvedFragment> holes = new ArrayList<UnresolvedFragment>();
                for (gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment fragment : site.fragments) {
                        UnresolvedFragment hole = UnresolvedFragment.of(fragment);
                        if (hole != null) {
                                holes.add(hole);
                        }
                }
                // Only a reduced argument has a materialization; rendering the provenance of an
                // unreduced one would fabricate text (the arguments of an unfoldable call glued
                // together). Its holes are still reported.
                String text = site.sqlText;
                if (site.sqlText == null && holes.isEmpty()) {
                        // The value did not reduce, yet nothing in its provenance is a hole: the
                        // producer that stopped the fold left no fragment (an undecidable CASE, a
                        // resource bound, a malformed call). "Not known" - never an exact zero.
                        return new DynamicHoleEvidence(-1, false, Collections.<UnresolvedFragment>emptyList(), text);
                }
                return new DynamicHoleEvidence(holes.size(), true, holes, text);
        }

        /**
         * True when the materialized text is nothing but value-unknown holes - a bare
         * {@code @sql} whose value the evaluator could not fold. Parsing that as SQL proves
         * nothing about the runtime statement, so such a site is reported as its
         * argument shape (with the hole evidence) instead of as a parse failure of text
         * that was never SQL.
         */
        private static boolean isWholeTextHole(
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site) {
                if (site == null || site.sqlText == null || site.fragments.isEmpty()) {
                        return false;
                }
                for (gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment fragment : site.fragments) {
                        if (fragment.isLiteral() || !fragment.valueUnknown) {
                                return false;
                        }
                }
                return true;
        }

        private String dynamicTrustReason(String prefix, int unprovenCount,
                        int unresolvedHoleCount, boolean holeCountExact) {
                String holes = holeCountExact ? unresolvedHoleCount + " unresolved fragment(s)"
                                : "unresolved fragment count unavailable from the producer";
                return prefix + "; " + holes
                                + (unprovenCount >= 0 ? "; " + unprovenCount + " unproven candidate relationship(s)" : "");
        }

        /**
         * Classify the lineage edges a folded dynamic site produced. {@code relsBefore} is the relation
         * snapshot taken immediately before the folded SQL was analyzed; the tail of the current relation set
         * is this site's delta (relationHolder is insertion-ordered). counts[0]=resolved (edge into a real
         * target column), counts[1]=partial (edge into a T-SQL variable / placeholder target). Edges whose
         * target is an intermediate result-set are ignored — only final-target edges are counted.
         */
        /**
         * String-building functions whose names show up as fabricated source "tables" when a partial
         * fold leaves a runtime-built object name in the re-parsed text (e.g.
         * {@code EXEC('... FROM ' + QUOTENAME(@tab))}).
         */
        private static final java.util.Set<String> DYNAMIC_NAME_BUILDER_FUNCTIONS = new HashSet<String>(
                        Arrays.asList("QUOTENAME", "REPLACE", "CONCAT", "FORMAT", "UPPER", "LOWER", "TRIM", "LTRIM", "RTRIM"));

        /**
         * Returns {@code {resolvedCount, partialCount, placeholderSeen, resultSetEdgeCount}} for the
         * lineage edges added after {@code beforeCount}.
         *
         * <ul>
         *   <li>{@code resolvedCount} — edges into a real base-table target column with no placeholder
         *       contamination anywhere in the new edge set.</li>
         *   <li>{@code partialCount} — edges into a variable / placeholder target, plus (when the edge
         *       set is contaminated) every edge that would otherwise have counted as resolved, so the
         *       public counts never claim usable lineage a placeholder actually feeds.</li>
         *   <li>{@code placeholderSeen} — 1 when any new edge draws from a fabricated placeholder table:
         *       a raw name starting with '@' (delimited {@code [@x]} identifiers are legal object names
         *       and are NOT placeholders), or — during a partial fold only — a variable-backed source
         *       table (Oracle {@code ' ... FROM ' || p_tab}) or a table named after a string-building
         *       function ({@code QUOTENAME} etc.).</li>
         *   <li>{@code resultSetEdgeCount} — clean edges into a result-set column (a folded dynamic
         *       {@code SELECT}'s projection). These contribute to the site-resolution decision but stay
         *       out of {@code resolvedCount}, which is documented as base-table targets only.</li>
         * </ul>
         */
        private int[] classifyDynamicSiteLineage(int beforeCount, boolean partialFold) {
                int resolved = 0;
                int partial = 0;
                int resultSetEdges = 0;
                boolean placeholderSeen = false;
                Relationship[] after = modelManager.getRelations();
                for (int i = beforeCount; i < after.length; i++) {
                        Relationship r = after[i];
                        if (r == null) {
                                continue;
                        }
                        if (hasPlaceholderSourceTable(r, partialFold)) {
                                placeholderSeen = true;
                        }
                        if (r.getTarget() instanceof ResultColumnRelationshipElement) {
                                resultSetEdges++;
                        } else if (r.getTarget() instanceof TableColumnRelationshipElement) {
                                TableColumn targetColumn = ((TableColumnRelationshipElement) r.getTarget()).getElement();
                                Table targetTable = targetColumn == null ? null : targetColumn.getTable();
                                if (isPlaceholderNamedTable(targetTable, partialFold)) {
                                        // Runtime-built INSERT destination (e.g. 'INSERT INTO '+QUOTENAME(@tab)+...)
                                        // — the target object is unknown, so the whole site is contaminated.
                                        placeholderSeen = true;
                                        partial++;
                                } else if (isUnresolvedTargetTable(targetTable)) {
                                        partial++;
                                } else {
                                        resolved++;
                                }
                        }
                }
                if (placeholderSeen) {
                        // Contaminated edges must not be surfaced as usable lineage
                        // (producedLineage() reads resolvedCount).
                        partial += resolved;
                        resolved = 0;
                        resultSetEdges = 0;
                }
                return new int[] { resolved, partial, placeholderSeen ? 1 : 0, resultSetEdges };
        }

        /**
         * Oracle DBMS_SQL resolution (plan Phase 5 slice 4; supersedes the Phase 1
         * visibility-only recording): a {@code DBMS_SQL.PARSE(c, <sql>, ...)} call is a
         * dynamic-SQL execution site. The SQL-text argument is folded through the shared
         * literal-bindable whitelist — inline literals, literal-composed locals, and
         * parameters bound at vetted literal call sites (same-file or cross-file via the
         * routine catalog) — and each folded text is analyzed through the ordinary inner-
         * SQL path. Anything that does not fold keeps an honest UNRESOLVED diagnostic;
         * PARSE_ERROR is reserved for compile-time literal text, mirroring the EXECUTE
         * IMMEDIATE status contract. Recording keys off PARSE, the call that carries the
         * SQL text, so a PARSE/EXECUTE pair maps to one site.
         */
        private void recordDbmsSqlSiteIfParseCall(TBasicStmt stmt, TFunctionCall functionCall) {
                if (functionCall == null || functionCall.getFunctionName() == null
                                || option.getVendor() != EDbVendor.dbvoracle) {
                        return;
                }
                String calledName = functionCall.getFunctionName().toString();
                if (!SQLUtil.compareIdentifier(EDbVendor.dbvoracle, ESQLDataObjectType.dotProcedure,
                                calledName, "DBMS_SQL.PARSE")
                                && !SQLUtil.compareIdentifier(EDbVendor.dbvoracle, ESQLDataObjectType.dotProcedure,
                                                calledName, "SYS.DBMS_SQL.PARSE")) {
                        return;
                }
                if (!option.isAnalyzeDynamicSql()) {
                        recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.DBMS_SQL,
                                        DynamicSqlSite.Status.UNRESOLVED,
                                        "dynamic SQL inner analysis disabled");
                        return;
                }
                boolean literalSql = false;
                DynamicSqlTrustMode trustMode = option.getDynamicSqlTrustMode();
                TExpression sqlArg = null;
                if (functionCall.getArgs() != null && functionCall.getArgs().size() >= 2) {
                        // Positional form: PARSE(c, <sql>, <lang>). Named association may reorder the
                        // arguments (statement => '...'), so resolve the named form first.
                        boolean namedForm = false;
                        for (int i = 0; i < functionCall.getArgs().size(); i++) {
                                TExpression arg = functionCall.getArgs().getExpression(i);
                                if (arg != null && arg.getExpressionType() == EExpressionType.ref_arrow_t) {
                                        namedForm = true;
                                        if (arg.getLeftOperand() != null
                                                        && SQLUtil.sameName(EDbVendor.dbvoracle, ESQLDataObjectType.dotColumn,
                                                                        arg.getLeftOperand().toString(), "statement")) {
                                                sqlArg = arg.getRightOperand();
                                                break;
                                        }
                                }
                        }
                        if (sqlArg == null && !namedForm) {
                                sqlArg = functionCall.getArgs().getExpression(1);
                        }
                        literalSql = sqlArg != null && sqlArg.getExpressionType() == EExpressionType.simple_constant_t;
                }
                if (sqlArg != null) {
                        TCustomSqlStatement routine = null;
                        for (int i = stmtStack.size() - 1; i >= 0; i--) {
                                if (stmtStack.get(i) instanceof TStoredProcedureSqlStatement) {
                                        routine = stmtStack.get(i);
                                        break;
                                }
                        }
                        List<String> foldedTexts;
                        try {
                                foldedTexts = gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                                .foldDbmsSqlTexts(routine, sqlArg, routineCatalog, 4);
                        } catch (RuntimeException ex) {
                                foldedTexts = new ArrayList<String>();
                        }
                        if (!foldedTexts.isEmpty()) {
                                Set<Relationship> shadowBefore = trustMode == DynamicSqlTrustMode.SHADOW
                                                ? snapshotDynamicRelationships() : null;
                                int dynamicSitesBefore = dynamicSqlSites.size();
                                int relsBeforeDynamic = modelManager.getRelations().length;
                                int errorsBeforeDynamic = errorInfos.size();
                                boolean analyzedAny = false;
                                boolean variantFailed = false;
                                List<Long> provenVariantRelationshipIds = new ArrayList<Long>();
                                for (String foldedText : foldedTexts) {
                                        int relationshipsBeforeVariant = modelManager.getRelations().length;
                                        int dynamicSitesBeforeVariant = dynamicSqlSites.size();
                                        int errorsBeforeVariant = errorInfos.size();
                                        TGSqlParser sqlparser = createSqlParser(option.getVendor());
                                        sqlparser.sqltext = foldedText;
                                        int result;
                                        try {
                                                result = parseWithCommentBindings(sqlparser);
                                        } catch (RuntimeException ex) {
                                                variantFailed = true;
                                                continue;
                                        }
                                        if (result != 0 || sqlparser.sqlstatements == null) {
                                                variantFailed = true;
                                                continue;
                                        }
                                        try {
                                                dynamicFoldDepth++;
                                                try {
                                                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                                                analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                                        }
                                                } finally {
                                                        dynamicFoldDepth--;
                                                }
                                                analyzedAny = true;
                                                if (errorInfos.size() == errorsBeforeVariant
                                                                && !hasIncompleteDynamicSqlSitesSince(dynamicSitesBeforeVariant)) {
                                                        provenVariantRelationshipIds.addAll(provenDynamicRelationshipIdsSince(
                                                                        relationshipsBeforeVariant, dynamicSitesBeforeVariant));
                                                }
                                        } catch (RuntimeException ex) {
                                                // An analyzer crash on folded text must neither surface as an
                                                // AnalyzeError blessed into output nor masquerade as resolved.
                                                variantFailed = true;
                                        }
                                }
                                // Inner analysis handlers may swallow their own crashes into
                                // errorInfos (never rethrowing to the catch above). Errors raised
                                // while analyzing SYNTHESIZED text carry misleading fragment-
                                // relative coordinates - roll them back and treat the variant as
                                // failed so the site status stays honest.
                                if (errorInfos.size() > errorsBeforeDynamic) {
                                        while (errorInfos.size() > errorsBeforeDynamic) {
                                                errorInfos.remove(errorInfos.size() - 1);
                                        }
                                        variantFailed = true;
                                }
                                int[] dynCounts = classifyDynamicSiteLineage(relsBeforeDynamic, false);
                                boolean nestedIncomplete = trustMode != DynamicSqlTrustMode.LEGACY
                                                && hasIncompleteDynamicSqlSitesSince(dynamicSitesBefore);
                                boolean aggregateIncomplete = variantFailed || nestedIncomplete;
                                int shadowUnproven = trustMode == DynamicSqlTrustMode.SHADOW && aggregateIncomplete
                                                ? Math.max(0, countNewDynamicRelationships(shadowBefore)
                                                                - provenVariantRelationshipIds.size()) : 0;
                                if (analyzedAny && !aggregateIncomplete) {
                                        recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.DBMS_SQL,
                                                        DynamicSqlSite.Status.RESOLVED, null, dynCounts[0], dynCounts[1],
                                                        0, 0, true, trustMode,
                                                        relsBeforeDynamic, dynamicSitesBefore,
                                                        provenVariantRelationshipIds);
                                        return;
                                }
                                if (analyzedAny) {
                                        // Some accepted variants could not be analyzed - the aggregate
                                        // picture is incomplete. SHADOW retains the historical candidates
                                        // and labels the aggregate as lacking per-edge proof.
                                        DynamicSqlSite.Status status = trustMode == DynamicSqlTrustMode.SHADOW
                                                        && (shadowUnproven > 0 || !provenVariantRelationshipIds.isEmpty())
                                                        ? DynamicSqlSite.Status.PARTIAL
                                                        : DynamicSqlSite.Status.UNRESOLVED;
                                        String reason = nestedIncomplete
                                                        ? "nested dynamic SQL in a folded DBMS_SQL variant is incomplete"
                                                        : "some folded DBMS_SQL variants failed to parse or analyze; lineage may be incomplete";
                                        recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.DBMS_SQL, status,
                                                        trustMode == DynamicSqlTrustMode.SHADOW
                                    ? dynamicTrustReason(reason + "; SHADOW retained historical candidates",
                                                                                        shadowUnproven, nestedIncomplete ? -1 : 0,
                                                                                        !nestedIncomplete)
                                                                        : reason,
                                                        dynCounts[0], dynCounts[1], shadowUnproven,
                                                        nestedIncomplete ? -1 : 0, !nestedIncomplete, trustMode,
                                                        relsBeforeDynamic, dynamicSitesBefore,
                                                        provenVariantRelationshipIds);
                                        return;
                                }
                                if (variantFailed && literalSql) {
                                        recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.DBMS_SQL,
                                                        DynamicSqlSite.Status.PARSE_ERROR,
                                                        "DBMS_SQL.PARSE literal SQL failed to parse", 0, 0,
                                                        0, 0, true, trustMode,
                                                        relsBeforeDynamic, dynamicSitesBefore);
                                        return;
                                }
                                if (variantFailed) {
                                        recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.DBMS_SQL,
                                                        DynamicSqlSite.Status.UNRESOLVED,
                                                        "folded DBMS_SQL text failed to parse", 0, 0,
                                                        0, 0, true, trustMode,
                                                        relsBeforeDynamic, dynamicSitesBefore);
                                        return;
                                }
                        }
                }
                String unresolvedReason = literalSql ? "DBMS_SQL.PARSE with literal SQL; inner SQL not analyzed"
                                : "DBMS_SQL.PARSE with runtime SQL text; inner SQL not analyzed";
                if (trustMode == DynamicSqlTrustMode.LEGACY) {
                        recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.DBMS_SQL,
                                        DynamicSqlSite.Status.UNRESOLVED, unresolvedReason);
                } else {
                        boolean runtimeText = !literalSql;
                        if (runtimeText && trustMode == DynamicSqlTrustMode.SHADOW) {
                                unresolvedReason = dynamicTrustReason("SHADOW observed no materialized DBMS_SQL candidate",
                                                0, -1, false);
                        }
                        recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.DBMS_SQL,
                                        DynamicSqlSite.Status.UNRESOLVED, unresolvedReason, 0, 0,
                                        0,
                                        runtimeText ? -1 : 0, !runtimeText, trustMode);
                }
        }

        private boolean hasIncompleteDynamicSqlSitesSince(int start) {
                return hasIncompleteDynamicSqlSitesSince(dynamicSqlSites, start);
        }

        private static boolean hasIncompleteDynamicSqlSitesSince(List<DynamicSqlSite> sites, int start) {
                for (int i = Math.max(0, start); i < sites.size(); i++) {
                        DynamicSqlSite site = sites.get(i);
                        if (site.getStatus() != DynamicSqlSite.Status.RESOLVED) {
                                return true;
                        }
                }
                return false;
        }

        /** True when any source of this edge is a fabricated placeholder table (see caller javadoc). */
        private boolean hasPlaceholderSourceTable(Relationship r, boolean partialFold) {
                if (r.getSources() == null) {
                        return false;
                }
                for (Object source : r.getSources()) {
                        if (!(source instanceof TableColumnRelationshipElement)) {
                                continue;
                        }
                        TableColumn sourceColumn = ((TableColumnRelationshipElement) source).getElement();
                        Table sourceTable = sourceColumn == null ? null : sourceColumn.getTable();
                        if (sourceTable == null || sourceTable.isPseudo()) {
                                continue;
                        }
                        if (sourceTable.isVariable()) {
                                // A variable-backed source inside a PARTIAL fold is the folded remnant of a
                                // runtime-built OBJECT NAME only when it stands in table position — its
                                // "columns" then carry real column names distinct from the variable's own
                                // name ('... FROM ' || p_tab reparsed as table p_tab with column s1). A
                                // scalar variable used as a value/predicate operand surfaces as a
                                // single-column variable whose column IS the variable name — legitimate,
                                // not contamination.
                                if (partialFold && sourceColumn != null && sourceColumn.getName() != null
                                                && sourceTable.getName() != null
                                                && !DlineageUtil.sameName(ESQLDataObjectType.dotColumn,
                                                                sourceColumn.getName(), sourceTable.getName())) {
                                        return true;
                                }
                                continue;
                        }
                        if (isPlaceholderNamedTable(sourceTable, partialFold)) {
                                return true;
                        }
                        // a file path a dynamic fold assembled at runtime ('... FROM ''' + @file + '''', Mantis 4962)
                        if (sourceTable.isPath() && sourceTable.isDynamicTemplate()) {
                                return true;
                        }
                }
                return false;
        }

        /**
         * A table whose NAME betrays a runtime-built object: a raw name starting with '@' (fold
         * artifact; delimited {@code [@x]} / {@code "@x"} are legal object names and do not match), or —
         * during a partial fold — a name equal to a string-building function left behind by the folder
         * ({@code QUOTENAME(...)} etc.). Applied to both edge sources and INSERT targets.
         */
        private boolean isPlaceholderNamedTable(Table table, boolean partialFold) {
                if (table == null) {
                        return false;
                }
                String name = table.getName() == null ? "" : table.getName().trim();
                if (name.startsWith("@")) {
                        return true;
                }
                // Locale-stable fold: default-locale toUpperCase turns "ltrim" into "LTRİM" under tr_TR.
                return partialFold && DYNAMIC_NAME_BUILDER_FUNCTIONS.contains(name.toUpperCase(Locale.ENGLISH));
        }

        /**
         * A folded dynamic site's target is "unresolved" when it is a T-SQL variable / placeholder rather
         * than a real object. When GSP only partially folds (e.g. {@code EXEC sp_executesql @sql} →
         * {@code INSERT INTO @p SELECT ...}), the re-parsed target is a table literally named {@code @p};
         * its {@code isVariable()} flag is not set, so the reliable signal is a name starting with '@'.
         */
        private boolean isUnresolvedTargetTable(Table table) {
                if (table == null) {
                        return true;
                }
                if (table.isVariable() || table.isPseudo()) {
                        return true;
                }
                String name = table.getName();
                if (name != null) {
                        // Raw-name check only: delimited [@x] / "@x" are legal permanent-object names,
                        // while the fold artifact keeps a bare leading '@'.
                        if (name.trim().startsWith("@")) {
                                return true;
                        }
                }
                return false;
        }

        /** True when a module name resolves to sp_executesql, ignoring schema qualifier and brackets/quotes. */
        private boolean isSpExecutesql(TObjectName moduleName) {
                if (moduleName == null) {
                        return false;
                }
                String s = moduleName.toString();
                int dot = s.lastIndexOf('.');
                if (dot >= 0) {
                        s = s.substring(dot + 1);
                }
                s = s.replace("[", "").replace("]", "").replace("\"", "").replace("`", "").trim();
                return "sp_executesql".equalsIgnoreCase(s);
        }

        /**
         * True when a module name is a <em>local</em> invocation of the system
         * procedure sp_execute_external_script whose input query therefore executes in
         * the caller's current database context.
         *
         * <p>Uses the parser's structured object/schema segmentation plus the
         * identifier-equality facade ({@link SQLUtil#sameName}) so vendor delimiter
         * rules are honored: a naive {@code lastIndexOf('.')} or delimiter strip would
         * mistake a delimited identifier that merely contains a dot
         * ({@code [dbo.sp_execute_external_script]}) or one with escaped delimiters
         * ({@code [sp_execute_external_]]script]}, {@code "sp_execute_external_""script"})
         * for the system procedure.
         *
         * <p>Only the unqualified form or a bare {@code sys} schema is accepted, and any
         * server or database qualifier is rejected. A {@code dbo.} (or other user
         * schema) qualifier denotes a user procedure, and a server/database qualifier
         * (e.g. a four-part {@code Srv.Db.sys.sp_execute_external_script} linked-server
         * call) means the input query resolves in a remote context this pass does not
         * model. In both cases the argument is left unanalyzed rather than analyzed
         * against the wrong objects.
         */
        private boolean isSpExecuteExternalScript(TObjectName moduleName) {
                if (moduleName == null || moduleName.getObjectToken() == null) {
                        return false;
                }
                EDbVendor vendor = option.getVendor();
                if (!SQLUtil.sameName(vendor, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotProcedure,
                                moduleName.getObjectToken().toString(), "sp_execute_external_script")) {
                        return false;
                }
                // A server or database qualifier changes (or makes remote) the context in
                // which the input query resolves; only handle the local, unqualified call.
                if (moduleName.getServerToken() != null || moduleName.getDatabaseToken() != null) {
                        return false;
                }
                TSourceToken schemaTok = moduleName.getSchemaToken();
                if (schemaTok == null) {
                        return true;
                }
                return SQLUtil.sameName(vendor, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotSchema,
                                schemaTok.toString(), "sys");
        }

        /**
         * Recover lineage for the query passed to sp_execute_external_script via its
         * input dataset (MantisBT #4606). The input value is a SQL string literal whose
         * SELECT reads real tables; analyze it as a normal statement so its
         * source-table -&gt; result-set lineage is emitted.
         *
         * <p>The input dataset is the {@code @input_data_1} parameter (named form) or,
         * for a positional call, the third argument — the documented signature is
         * {@code (@language, @script, @input_data_1, ...)}. Only that one parameter
         * carries a query; its siblings {@code @input_data_1_name},
         * {@code @input_data_1_order_by_columns} and
         * {@code @input_data_1_partition_by_columns} are identifiers / column lists,
         * NOT queries — analyzing them would attach lineage to the wrong objects, so
         * named matching is exact and positional matching is restricted to the third
         * slot.
         *
         * <p>Only a plain string literal is materialized. A variable-valued argument is
         * left unanalyzed: the parse-time symbol table is not available in this pass,
         * so its value cannot be statically resolved here (the same unresolved-value
         * limitation as the general dynamic-SQL case).
         *
         * <p>The script body is opaque (arbitrary Python/R can reorder, drop, or
         * synthesize columns), so by default the input query's result set is NOT
         * connected to the {@code WITH RESULT SETS} output columns — that mapping is
         * unprovable. Only when {@link Option#isAssumeExternalScriptPassthrough()} is
         * explicitly enabled does {@link #buildExternalScriptPassthrough} add that
         * connection, tagged {@link EffectType#external_script_passthrough} to keep it
         * distinguishable from proven lineage.
         */
        private void analyzeExternalScriptInputData(TMssqlExecute executeStmt) {
                TExecParameterList params = executeStmt.getParameters();
                if (params == null) {
                        return;
                }
                // T-SQL allows a positional prefix followed by named arguments; once an
                // argument is named, every later one must be named too. So a positional
                // argument is only valid while no NAMED argument has appeared before it.
                // The documented signature is (@language, @script, @input_data_1, ...), so
                // the third positional argument (index 2) is @input_data_1.
                boolean namedBefore = false;
                for (int i = 0; i < params.size(); i++) {
                        TExecParameter param = params.getExecParameter(i);
                        TObjectName pname = param.getParameterName();
                        boolean isInputData1;
                        if (pname != null) {
                                String nm = pname.toString();
                                if (nm.startsWith("@")) {
                                        nm = nm.substring(1);
                                }
                                isInputData1 = "input_data_1".equalsIgnoreCase(nm.trim()); // non-identifier-compare: T-SQL system-proc parameter name
                                namedBefore = true;
                        } else {
                                isInputData1 = !namedBefore && i == 2;
                        }
                        if (!isInputData1 || param.getParameterValue() == null) {
                                continue;
                        }
                        String sql = materializeTSqlStringLiteral(param.getParameterValue().toString());
                        if (sql != null && sql.trim().length() > 0) {
                                ResultSet inputResultSet = analyzeExternalScriptInputQuery(sql);
                                // Opt-in only: bridge the opaque script by assuming the input dataset
                                // is passed through to the WITH RESULT SETS output columns positionally
                                // (EffectType.external_script_passthrough). Off by default because the
                                // script may reorder/drop/add columns, so these edges are assumed, not
                                // proven.
                                if (option.isAssumeExternalScriptPassthrough() && inputResultSet != null) {
                                        buildExternalScriptPassthrough(executeStmt, inputResultSet);
                                }
                        }
                        // Only @input_data_1 carries a query; nothing else to look at.
                        return;
                }
        }

        /**
         * Parse and analyze an sp_execute_external_script input query, returning the
         * ResultSet model of its (last) top-level SELECT, or null. Behaves like
         * {@link #executeDynamicSql(String)} but hands back the result set so the
         * optional passthrough model can wire it to the WITH RESULT SETS output.
         */
        private ResultSet analyzeExternalScriptInputQuery(String sql) {
                TGSqlParser sqlparser = createSqlParser(option.getVendor());
                sqlparser.sqltext = sql;
                if (parseWithCommentBindings(sqlparser) != 0) {
                        return null;
                }
                ResultSet resultSet = null;
                // Dynamic inner analysis: its references are NOT static statements of the unit
                // and must not veto dynamic-template marks (see dynamicFoldDepth).
                dynamicFoldDepth++;
                try {
                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                TCustomSqlStatement stmt = sqlparser.sqlstatements.get(i);
                                analyzeCustomSqlStmt(stmt);
                                if (stmt instanceof TSelectSqlStatement) {
                                        Object model = modelManager.getModel(stmt);
                                        if (model instanceof ResultSet) {
                                                resultSet = (ResultSet) model;
                                        }
                                }
                        }
                } finally {
                        dynamicFoldDepth--;
                }
                return resultSet;
        }

        /**
         * Under the opt-in passthrough assumption, wire the external-script input
         * dataset to its declared {@code WITH RESULT SETS} output columns positionally,
         * emitting {@link EffectType#external_script_passthrough} edges and binding the
         * synthesized output ResultSet to the EXEC statement so an
         * {@code INSERT ... EXEC} consumer can inherit it (see the INSERT..EXEC path in
         * {@link #analyzeInsertStmt}).
         */
        private void buildExternalScriptPassthrough(TMssqlExecute executeStmt, ResultSet inputResultSet) {
                TColumnDefinitionList outputColumns = firstInlineResultSetColumns(executeStmt);
                if (outputColumns == null || outputColumns.size() == 0) {
                        // No declared output columns (e.g. WITH RESULT SETS NONE / UNDEFINED):
                        // there is nothing to pass the input through to.
                        return;
                }
                List<ResultColumn> inputColumns = inputResultSet.getColumns();
                // A star projection ("SELECT *") has unknown width, so positional
                // correspondence to the declared output cannot be established -- decline
                // rather than mis-map a single star column onto the first output column.
                for (ResultColumn inputColumn : inputColumns) {
                        if (inputColumn != null && inputColumn.isStarColumn()) {
                                return;
                        }
                }
                ResultSet outputResultSet = modelFactory.createResultSet(executeStmt, false);
                Process process = modelFactory.createProcess(executeStmt);
                // Materialize the FULL declared output schema (so every WITH RESULT SETS
                // column is available to a downstream INSERT..EXEC), preserving cardinality
                // by position via the raw ResultColumn constructor (the name-keyed factory
                // overload would collapse duplicate declared names). Passthrough edges are
                // added only for positions that have a matching input column.
                for (int i = 0; i < outputColumns.size(); i++) {
                        TObjectName outputName = outputColumns.getColumn(i).getColumnName();
                        if (outputName == null) {
                                continue;
                        }
                        ResultColumn outputColumn = new ResultColumn(outputResultSet, outputName);
                        if (i < inputColumns.size() && inputColumns.get(i) != null) {
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.external_script_passthrough);
                                relation.setTarget(new ResultColumnRelationshipElement(outputColumn));
                                relation.addSource(new ResultColumnRelationshipElement(inputColumns.get(i)));
                                relation.setProcess(process);
                        }
                }
        }

        /** The column list of the first inline {@code WITH RESULT SETS ((...))} definition of an EXEC, or null. */
        private gudusoft.gsqlparser.nodes.TColumnDefinitionList firstInlineResultSetColumns(TMssqlExecute executeStmt) {
                gudusoft.gsqlparser.nodes.mssql.TExecuteOption execOption = executeStmt.getExecuteOption();
                if (!(execOption instanceof gudusoft.gsqlparser.nodes.mssql.TResultSetsExecuteOption)) {
                        return null;
                }
                for (gudusoft.gsqlparser.nodes.mssql.TResultSetDefinition definition
                                : ((gudusoft.gsqlparser.nodes.mssql.TResultSetsExecuteOption) execOption).getDefinitions()) {
                        if (definition instanceof gudusoft.gsqlparser.nodes.mssql.TInlineResultSetDefinition) {
                                return ((gudusoft.gsqlparser.nodes.mssql.TInlineResultSetDefinition) definition)
                                                .getColumnDefinitionList();
                        }
                }
                return null;
        }

        /**
         * Result sets that an {@code INSERT ... EXEC <proc>} can consume: the result
         * sets of the procedure's trailing SELECT(s), or — when the procedure has no
         * such SELECT — the {@code WITH RESULT SETS} output(s) synthesized for its
         * internal sp_execute_external_script call. The latter exist only when the
         * passthrough assumption is enabled ({@link Option#isAssumeExternalScriptPassthrough()}),
         * so with the option off this reduces to the previous SELECT-only behavior.
         */
        private List<ResultSet> collectCalleeResultSets(TStoredProcedureSqlStatement procedureStmt) {
                List<ResultSet> resultSets = new ArrayList<ResultSet>();
                List<TSelectSqlStatement> selects = getLastSelectStmt(procedureStmt);
                if (selects != null) {
                        for (TSelectSqlStatement select : selects) {
                                Object model = modelManager.getModel(select);
                                if (model instanceof ResultSet) {
                                        resultSets.add((ResultSet) model);
                                }
                        }
                }
                // A procedure may return an ordinary SELECT result set AND an external-script
                // result set; INSERT..EXEC consumes every returned (compatible) result set, so
                // include the passthrough output(s) as well, not only when no SELECT exists.
                // externalScriptOutputResultSets is empty unless the passthrough option is on,
                // so with the option off this reduces to the previous SELECT-only behavior.
                resultSets.addAll(externalScriptOutputResultSets(procedureStmt));
                return resultSets;
        }

        /**
         * Result sets an {@code INSERT ... EXEC <target>} consumes. When the target is a
         * user stored procedure, this is {@link #collectCalleeResultSets}. When it is a
         * DIRECT call to sp_execute_external_script (no wrapping procedure), the
         * synthesized WITH RESULT SETS output is bound to the EXEC statement itself, so
         * it is fetched directly. Empty unless the passthrough assumption is enabled.
         */
        private List<ResultSet> calleeResultSetsForInsertExec(TMssqlExecute executeStmt, Procedure procedure) {
                if (procedure != null && procedure.getProcedureObject() instanceof TStoredProcedureSqlStatement) {
                        return collectCalleeResultSets((TStoredProcedureSqlStatement) procedure.getProcedureObject());
                }
                if (isSpExecuteExternalScript(executeStmt.getModuleName())) {
                        Object model = modelManager.getModel(executeStmt);
                        if (model instanceof ResultSet) {
                                return java.util.Collections.singletonList((ResultSet) model);
                        }
                }
                return new ArrayList<ResultSet>();
        }

        /**
         * WITH RESULT SETS output result sets bound to sp_execute_external_script calls
         * inside a procedure body (the passthrough model binds one to each such EXEC).
         * Empty unless the passthrough assumption is enabled.
         */
        private List<ResultSet> externalScriptOutputResultSets(TStoredProcedureSqlStatement procedureStmt) {
                final List<ResultSet> resultSets = new ArrayList<ResultSet>();
                procedureStmt.acceptChildren(new TParseTreeVisitor() {
                        @Override
                        public void preVisit(TMssqlExecute execute) {
                                if (isSpExecuteExternalScript(execute.getModuleName())) {
                                        Object model = modelManager.getModel(execute);
                                        if (model instanceof ResultSet) {
                                                resultSets.add((ResultSet) model);
                                        }
                                }
                        }
                });
                return resultSets;
        }

        /**
         * Materialize a T-SQL string literal: strip the {@code N'...'} / {@code '...'}
         * wrapper and unescape doubled single quotes ({@code ''} -&gt; {@code '}).
         * Unlike {@link TBaseType#getStringInsideLiteral(String)} this does NOT treat
         * {@code \'} as an escape — backslash is an ordinary character in T-SQL, so a
         * source such as an {@code OPENROWSET} path must survive unchanged. Returns
         * null when the argument is not a plain string literal (e.g. a variable).
         */
        private static String materializeTSqlStringLiteral(String raw) {
                if (raw == null) {
                        return null;
                }
                String s = raw.trim();
                int start = -1;
                if (s.length() >= 2 && s.charAt(0) == '\'') {
                        start = 1;
                } else if (s.length() >= 3 && (s.charAt(0) == 'N' || s.charAt(0) == 'n') && s.charAt(1) == '\'') {
                        start = 2;
                }
                if (start < 0 || s.charAt(s.length() - 1) != '\'') {
                        return null;
                }
                return s.substring(start, s.length() - 1).replace("''", "'");
        }

        /** True when this EXEC form would expand SQL text rather than invoke an
         * ordinary statically named stored procedure. */
        private boolean expandsDynamicSql(TMssqlExecute e) {
                return e.getSqlText() != null
                                || e.getExecType() == TBaseType.metExecStringCmd
                                || isSpExecutesql(e.getModuleName());
        }

        /** Kind of a {@link TMssqlExecute} dynamic site: sp_executesql vs the EXEC(string) family. */
        private DynamicSqlSite.Kind dynamicKindOf(TMssqlExecute e) {
                if (e.getExecType() == TBaseType.metExecStringCmd) {
                        return DynamicSqlSite.Kind.EXEC_STRING;
                }
                if (isSpExecutesql(e.getModuleName())) {
                        return DynamicSqlSite.Kind.SP_EXECUTESQL;
                }
                return DynamicSqlSite.Kind.OTHER;
        }

        /** The dynamic-SQL argument expression of a {@link TMssqlExecute}, or null. */
        private TExpression dynamicArgOf(TMssqlExecute e) {
                if (e.getExecType() == TBaseType.metExecStringCmd) {
                        if (e.getStringValues() != null && e.getStringValues().size() > 0) {
                                return e.getStringValues().getExpression(0);
                        }
                        return null;
                }
                if (e.getParameters() != null && e.getParameters().size() > 0) {
                        TExecParameter p = e.getParameters().getExecParameter(0);
                        if (p != null) {
                                return p.getParameterValue();
                        }
                }
                return null;
        }

        /**
         * True only when the dynamic-SQL argument is a compile-time string literal. A variable or
         * expression argument is data-driven: even when GSP partially folds it (e.g. {@code @sql} →
         * {@code INSERT INTO @t SELECT ...} with an unresolved parameter left in), the site is NOT
         * fully resolved, so it must not be reported RESOLVED.
         */
        private boolean isLiteralDynamicArg(TMssqlExecute e) {
                TExpression arg = dynamicArgOf(e);
                return arg != null && arg.getExpressionType() == EExpressionType.simple_constant_t;
        }

        /** Refine the UNRESOLVED reason by inspecting the dynamic argument expression. */
        private String dynamicReasonOf(TMssqlExecute e) {
                TExpression arg = dynamicArgOf(e);
                if (arg == null) {
                        return "dynamic SQL target could not be resolved";
                }
                if (arg.getExpressionType() == EExpressionType.simple_object_name_t && arg.getObjectOperand() != null
                                && arg.getObjectOperand().getDbObjectType() == EDbObjectType.variable) {
                        return "argument is a runtime variable";
                }
                if (arg.getExpressionType() == EExpressionType.simple_constant_t) {
                        return "inline literal not folded; no lineage produced";
                }
                return "argument is a runtime expression or partially-folded variable";
        }

        private void executeDynamicSql(String sql) {
                TGSqlParser sqlparser = createSqlParser(option.getVendor());
                sqlparser.sqltext = sql;
                int result = parseWithCommentBindings(sqlparser);
                if (result == 0) {
                        dynamicFoldDepth++;
                        try {
                                for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                        analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                }
                        } finally {
                                dynamicFoldDepth--;
                        }
                }
        }

        /**
         * Callback invoked from snowflake.js (the script shim run by
         * {@link #extractSnowflakeSQLFromProcedure}) for every SQL text a
         * JavaScript procedure body passes to snowflake.execute() /
         * snowflake.createStatement(). The script resolves this method by name
         * at runtime, so it must stay public and keep this exact signature —
         * renaming it to executeDynamicSql broke JavaScript-procedure lineage
         * with "analyzer.extractSnowflakeSQL is not a function" (Mantis 4590).
         */
        public void extractSnowflakeSQL(String sql) {
                executeDynamicSql(sql);
        }

        private void extractSnowflakeSQLFromProcedure(TCreateProcedureStmt procedure) {
                Map<String, String> argMap = new LinkedHashMap<String, String>();
                if (procedure.getParameterDeclarations() != null) {
                        for (int i = 0; i < procedure.getParameterDeclarations().size(); i++) {
                                TParameterDeclaration def = procedure.getParameterDeclarations().getParameterDeclarationItem(i);
                                argMap.put(def.getParameterName().toString(), def.getDataType().getDataTypeName());
                        }
                }
                StringBuilder buffer = new StringBuilder();
                buffer.append("(function(");
                String[] args = argMap.keySet().toArray(new String[0]);
                for (int i = 0; i < args.length; i++) {
                        buffer.append(args[i].toUpperCase(Locale.ROOT));
                        if (i < args.length - 1) {
                                buffer.append(",");
                        }
                }
                buffer.append("){\n");

                int start = -1;
                int end = -1;
                boolean dollar = false;
                boolean quote = false;
                if (procedure.getRoutineBody().indexOf("$$") != -1) {
                        start = procedure.getRoutineBody().indexOf("$$") + 2;
                        end = procedure.getRoutineBody().lastIndexOf("$$") - 1;
                        dollar = true;
                } else if (procedure.getRoutineBody().indexOf("'") != -1) {
                        start = procedure.getRoutineBody().indexOf("'") + 1;
                        end = procedure.getRoutineBody().lastIndexOf("'");
                        quote = true;
                }
                String body = procedure.getRoutineBody().substring(start, end);
                if (dollar && body.indexOf("`") != -1) {
                        Pattern pattern = Pattern.compile("`.+?`", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
                        Matcher matcher = pattern.matcher(body);
                        StringBuffer replaceBuffer = new StringBuffer();
                        while (matcher.find()) {
                                String condition = matcher.group().replace("\r\n", "\n").replace("'", "\\\\'")
                                                .replace("\n", "\\\\n'\n+'").replace("`", "'").replace("$", "RDS_CHAR_DOLLAR");
                                matcher.appendReplacement(replaceBuffer, condition);
                        }
                        matcher.appendTail(replaceBuffer);
                        body = replaceBuffer.toString().replace("RDS_CHAR_DOLLAR", "$");
                }
                if (quote && body.indexOf("'") != -1) {
                        body = body.replace("''", "'");
                }
                buffer.append(body);
                buffer.append("})(");
                for (int i = 0; i < args.length; i++) {
                        String type = argMap.get(args[i]);
                        if (type.equalsIgnoreCase("VARCHAR")) {
                                buffer.append("'pseudo'");
                        } else if (type.equalsIgnoreCase("STRING")) {
                                buffer.append("'pseudo'");
                        } else if (type.equalsIgnoreCase("CHAR")) {
                                buffer.append("'pseudo'");
                        } else if (type.equalsIgnoreCase("CHARACTER")) {
                                buffer.append("'pseudo'");
                        } else if (type.equalsIgnoreCase("TEXT")) {
                                buffer.append("'pseudo'");
                        } else if (type.equalsIgnoreCase("BINARY")) {
                                buffer.append("'pseudo'");
                        } else if (type.equalsIgnoreCase("VARBINARY")) {
                                buffer.append("'pseudo'");
                        } else if (type.equalsIgnoreCase("BOOLEAN")) {
                                buffer.append(true);
                        } else if (type.equalsIgnoreCase("FLOAT")) {
                                buffer.append("1.0");
                        } else if (type.equalsIgnoreCase("FLOAT4")) {
                                buffer.append("1.0");
                        } else if (type.equalsIgnoreCase("FLOAT8")) {
                                buffer.append("1.0");
                        } else if (type.equalsIgnoreCase("DOUBLE")) {
                                buffer.append("1.0");
                        } else if (type.equalsIgnoreCase("DOUBLE PRECISION")) {
                                buffer.append("1.0");
                        } else if (type.equalsIgnoreCase("REAL")) {
                                buffer.append("1.0");
                        } else if (type.equalsIgnoreCase("NUMBER")) {
                                buffer.append("1.0");
                        } else if (type.equalsIgnoreCase("DECIMAL")) {
                                buffer.append("1.0");
                        } else if (type.equalsIgnoreCase("NUMERIC")) {
                                buffer.append("1.0");
                        } else if (type.equalsIgnoreCase("INT")) {
                                buffer.append("1");
                        } else if (type.equalsIgnoreCase("INTEGER")) {
                                buffer.append("1");
                        } else if (type.equalsIgnoreCase("BIGINT")) {
                                buffer.append("1");
                        } else if (type.equalsIgnoreCase("SMALLINT")) {
                                buffer.append("1");
                        } else if (type.equalsIgnoreCase("DATE")) {
                                buffer.append("new Date()");
                        } else if (type.equalsIgnoreCase("DATETIME")) {
                                buffer.append("new Date()");
                        } else if (type.equalsIgnoreCase("TIME")) {
                                buffer.append("new Date()");
                        } else if (type.equalsIgnoreCase("TIMESTAMP")) {
                                buffer.append("new Date()");
                        } else if (type.equalsIgnoreCase("TIMESTAMP_LTZ")) {
                                buffer.append("new Date()");
                        } else if (type.equalsIgnoreCase("TIMESTAMP_NTZ")) {
                                buffer.append("new Date()");
                        } else if (type.equalsIgnoreCase("TIMESTAMP_TZ")) {
                                buffer.append("new Date()");
                        } else if (type.equalsIgnoreCase("VARIANT")) {
                                buffer.append("{}");
                        } else if (type.equalsIgnoreCase("OBJECT")) {
                                buffer.append("{}");
                        } else if (type.equalsIgnoreCase("ARRAY")) {
                                buffer.append("[]");
                        } else if (type.equalsIgnoreCase("GEOGRAPHY")) {
                                buffer.append("{}");
                        }
                        if (i < args.length - 1) {
                                buffer.append(",");
                        }
                }
                buffer.append(");");

                try {
                        ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
                        ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");
                        if (nashorn == null) {
                                // The Nashorn engine was removed from the JDK in Java 15, so the
                                // JavaScript body cannot be executed to extract the SQL it runs.
                                // Try the body as plain SQL; otherwise keep the procedure model
                                // (with its declared language) and skip the body (Mantis 4590).
                                TGSqlParser sqlparser = createSqlParser(option.getVendor());
                                sqlparser.sqltext = body;
                                if (parseWithCommentBindings(sqlparser) == 0) {
                                        dynamicFoldDepth++;
                                        try {
                                                for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                                        analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                                }
                                        } finally {
                                                dynamicFoldDepth--;
                                        }
                                }
                                return;
                        }
                        nashorn.put("analyzer", this);
                        nashorn.eval(new InputStreamReader(
                                        getClass().getResourceAsStream("/gudusoft/gsqlparser/parser/snowflake/snowflake.js")));
                        nashorn.eval(new StringReader(buffer.toString()));
                } catch (ScriptException e) {
                        TGSqlParser sqlparser = createSqlParser(option.getVendor());
                        sqlparser.sqltext = body;
                        int result = parseWithCommentBindings(sqlparser);
                        if (result == 0) {
                                dynamicFoldDepth++;
                                try {
                                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                                analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                        }
                                } finally {
                                        dynamicFoldDepth--;
                                }
                                return;
                        }
                        ErrorInfo errorInfo = new ErrorInfo();
                        errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                        errorInfo.setErrorMessage("Invoke script error: " + e.getMessage());
                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(procedure.getStartToken().lineNo,
                                        procedure.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(procedure.getEndToken().lineNo,
                                        procedure.getEndToken().columnNo + procedure.getEndToken().getAstext().length(),
                                        ModelBindingManager.getGlobalHash()));
                        errorInfos.add(errorInfo);
                }
        }

        private void analyzeHiveLoadStmt(THiveLoad stmt) {
                if (stmt.getPath() != null && stmt.getTable() != null) {
                        Table uriFile = modelFactory.createTableByName(stmt.getPath(), true);
                        uriFile.setPath(true);
                        uriFile.setCreateTable(true);
                        TObjectName fileUri = new TObjectName();
                        fileUri.setString("uri=" + stmt.getPath());
                        TableColumn fileUriColumn = modelFactory.createFileUri(uriFile, fileUri);

                        Table tableModel = modelFactory.createTable(stmt.getTable());
                        Process process = modelFactory.createProcess(stmt);
                        tableModel.addProcess(process);

                        TPartitionExtensionClause p = stmt.getTable().getPartitionExtensionClause();
                        if (p.getKeyValues() != null && p.getKeyValues().size() > 0) {
                                for (int i = 0; i < p.getKeyValues().size(); i++) {
                                        TExpression expression = p.getKeyValues().getExpression(i);
                                        if (expression.getLeftOperand().getExpressionType() == EExpressionType.simple_object_name_t) {
                                                modelFactory.createTableColumn(tableModel, expression.getLeftOperand().getObjectOperand(),
                                                                true);
                                        }
                                }
                        }

                        for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                relation.setTarget(new TableColumnRelationshipElement(tableModel.getColumns().get(j)));
                                relation.setProcess(process);
                        }
                }
        }
        
        /**
         * MySQL {@code LOAD DATA INFILE 'file' INTO TABLE t [(col, @var, ...)] [SET col = expr, ...]} (Mantis 4963). The
         * file is a path node, as for BULK INSERT. With a column list its fields reach the columns that hold them
         * ({@link TLoadDataStmt#getLoadedColumnList()}); without one they reach the table as a whole, its load column
         * {@code *}, because the fields map to the columns by position.
         */
        private void analyzeLoadDataStmt(TLoadDataStmt stmt) {
                TObjectName tableName = stmt.getTableName();
                if (tableName == null || stmt.getFileName() == null) {
                        return;
                }
                String literal = stmt.getFileName().toString().trim();
                if (stmt.getFileName().tokentype == ETokenType.ttdqstring && literal.length() >= 2) {
                        // INFILE "/data/x.csv" names the file '/data/x.csv' names: one path node, by one spelling
                        literal = "'" + literal.substring(1, literal.length() - 1).replace("'", "''") + "'";
                }
                if (SQLUtil.isEmpty(stringLiteralValue(literal))) {
                        return;
                }
                Table intoTable = modelFactory.createTableByName(tableName, false);
                if (intoTable == null) {
                        return;
                }
                List<TableColumn> targets = new ArrayList<TableColumn>();
                if (stmt.getColumnList() == null) {
                        TableColumn star = intoTable.getLoadColumn();
                        if (star == null) {
                                star = new TableColumn(intoTable, DlineageUtil.syntheticStarName());
                                star.setExpandStar(false);
                                star.setPseduo(true);
                                intoTable.setLoadColumn(star);
                        }
                        targets.add(star);
                } else {
                        for (TObjectName column : stmt.getLoadedColumnList()) {
                                targets.add(modelFactory.createTableColumn(intoTable, column, true));
                        }
                }
                Process process = modelFactory.createProcess(stmt);
                intoTable.addProcess(process);

                Table pathModel = modelFactory.createTableByName(literal, true);
                // a file is no object of the database a USE names
                pathModel.setPath(true, false);
                pathModel.setCreateTable(true);
                TObjectName fileUri = new TObjectName();
                fileUri.setString(literal);
                TableColumn fileUriColumn = modelFactory.createFileUri(pathModel, fileUri);

                for (TableColumn target : targets) {
                        if (target == null) {
                                continue;
                        }
                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                        relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                        relation.setTarget(new TableColumnRelationshipElement(target));
                        relation.setProcess(process);
                }
        }

        private void analyzeUnloadStmt(TUnloadStmt unloadStmt) {
                if (unloadStmt.getSelectSqlStatement() != null && unloadStmt.getS3() != null) {

                        Table uriFile = modelFactory.createTableByName(unloadStmt.getS3(), true);
                        uriFile.setPath(true);
                        uriFile.setCreateTable(true);
                        TObjectName fileUri = new TObjectName();
                        fileUri.setString("uri=" + unloadStmt.getS3());
                        TableColumn fileUriColumn = modelFactory.createFileUri(uriFile, fileUri);

                        Process process = modelFactory.createProcess(unloadStmt);
                        uriFile.addProcess(process);

                        TCustomSqlStatement stmt = unloadStmt.getSelectSqlStatement();
                        analyzeCustomSqlStmt(stmt);
                        if (stmt instanceof TSelectSqlStatement) {
                                TSelectSqlStatement select = (TSelectSqlStatement) stmt;
                                ResultSet resultSetModel = (ResultSet) modelManager.getModel(select);
                                if (resultSetModel != null) {
                                        for (int j = 0; j < resultSetModel.getColumns().size(); j++) {
                                                ResultColumn resultColumn = resultSetModel.getColumns().get(j);
                                                if (resultColumn.hasStarLinkColumn()
                                                                && resultColumn.starLinkCount() > 0) {
                                                        for (int k = 0; k < resultColumn.starLinkCount(); k++) {
                                                                ResultColumn expandStarColumn = modelFactory.createResultColumn(resultSetModel,
                                                                                resultColumn.getStarLinkColumnName(k), false);
                                                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                                dataflowRelation.setEffectType(EffectType.unload);
                                                                dataflowRelation
                                                                                .addSource(new ResultColumnRelationshipElement(expandStarColumn));
                                                                dataflowRelation.setTarget(new TableColumnRelationshipElement(fileUriColumn));
                                                                dataflowRelation.setProcess(process);
                                                        }
                                                }
                                                if (!resultColumn.hasStarLinkColumn() || resultColumn.isShowStar()) {
                                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                        dataflowRelation.setEffectType(EffectType.unload);
                                                        dataflowRelation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(fileUriColumn));
                                                        dataflowRelation.setProcess(process);
                                                }
                                        }
                                }
                        }
                }

        }

        private void analyzeCopyIntoStmt(TSnowflakeCopyIntoStmt stmt) {
                if (stmt.getTableName() != null) {
                        if (stmt.getStageLocation() != null) {
                                Table intoTable = modelManager
                                                .getTableByName(DlineageUtil.getTableIdentityKey(stmt.getTableName().toString()));
                                if (intoTable == null) {
                                        intoTable = modelFactory.createTableByName(stmt.getTableName(), false);
                                }
                                // An explicit COPY column list selects only those destination columns,
                                // even when a previous DDL statement supplied the complete table schema.
                                List<TableColumn> copyColumns = new ArrayList<TableColumn>();
                                if (stmt.getSubQuery() == null && stmt.getTableColumnList() != null) {
                                        for (int i = 0; i < stmt.getTableColumnList().size(); i++) {
                                                TableColumn column = modelFactory.createTableColumn(intoTable,
                                                                stmt.getTableColumnList().getObjectName(i), false);
                                                if (column != null) copyColumns.add(column);
                                        }
                                } else {
                                        if (intoTable.getColumns().isEmpty()) {
                                                TObjectName starColumn = DlineageUtil.syntheticStarName();
                                                TableColumn column = modelFactory.createTableColumn(intoTable, starColumn, false);
                                                if (column != null) {
                                                        column.setExpandStar(false);
                                                        column.setPseduo(true);
                                                }
                                        }
                                        copyColumns.addAll(intoTable.getColumns());
                                }
                                Process process = modelFactory.createProcess(stmt);
                                intoTable.addProcess(process);

                                TObjectName stageName = stmt.getStageLocation().getStageName();
                                if (stageName == null || stmt.getStageLocation().getTableName() != null) {
                                        stageName = stmt.getStageLocation().getTableName();
                                }
                                if (stageName != null) {
                                        Table stage = modelManager.getTableByName(DlineageUtil.getTableIdentityKey(stageName.toString()));
                                        if (stage == null) {
                                                stage = modelFactory.createStage(stageName);
                                                stage.setCreateTable(true);
                                                stage.setStage(true);
                                                String stagePath = stmt.getStageLocation().getPath() == null ? null
                                                                : stmt.getStageLocation().getPath().toString();
                                                if (stagePath != null) {
                                                        stage.setLocation(stagePath);
                                                        TObjectName location = new TObjectName();
                                                        location.setString(stagePath);
                                                        modelFactory.createStageLocation(stage, location);
                                                } else {
                                                        stage.setLocation("unknownPath");
                                                        TObjectName location = new TObjectName();
                                                        location.setString("unknownPath");
                                                        modelFactory.createStageLocation(stage, location);
                                                }
                                        }

                                        if (stage != null && intoTable != null) {
                                                if (intoTable != null && !copyColumns.isEmpty() && !stage.getColumns().isEmpty()) {
                                                        for (int i = 0; i < copyColumns.size(); i++) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.addSource(new TableColumnRelationshipElement(stage.getColumns().get(0)));
                                                                relation.setTarget(new TableColumnRelationshipElement(copyColumns.get(i)));
                                                                relation.setProcess(process);
                                                        }
                                                }
                                        }
                                } else if (stmt.getStageLocation().getExternalLocation() != null) {
                                        Table pathModel = modelFactory.createTableByName(stmt.getStageLocation().getExternalLocation(),
                                                        true);
                                        pathModel.setPath(true);
                                        pathModel.setCreateTable(true);
                                        TableColumn fileUriColumn = modelFactory.createFileUri(pathModel,
                                                        stmt.getStageLocation().getExternalLocation());
                                        if (intoTable != null) {
                                                if (intoTable != null && !copyColumns.isEmpty()) {
                                                        for (int i = 0; i < copyColumns.size(); i++) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                                                relation.setTarget(new TableColumnRelationshipElement(copyColumns.get(i)));
                                                                relation.setProcess(process);
                                                        }
                                                }
                                        }
                                }
                        }
                        else if (stmt.getSubQuery() != null) {
                                analyzeSelectStmt(stmt.getSubQuery());
                                
                                Table intoTable = modelManager
                                                .getTableByName(DlineageUtil.getTableIdentityKey(stmt.getTableName().toString()));
                                if (intoTable == null) {
                                        intoTable = modelFactory.createTableByName(stmt.getTableName(), false);
                                        TObjectName starColumn = DlineageUtil.syntheticStarName();
                                        TableColumn column = modelFactory.createTableColumn(intoTable, starColumn, false);
                                        if (column != null) {
                                                column.setExpandStar(true);
                                                column.setPseduo(true);
                                        }

                                        Process process = modelFactory.createProcess(stmt);
                                        intoTable.addProcess(process);

                                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt.getSubQuery());
                                        if (resultSetModel != null && column != null) {
                                                for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                                        ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                        dataflowRelation.setEffectType(EffectType.copy);
                                                        dataflowRelation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(column));
                                                        dataflowRelation.setProcess(process);
                                                }
                                        }
                                }
                        }
                }
        }

        private void analyzeRedshiftCopyStmt(TRedshiftCopy stmt) {
                if (stmt.getTableName() != null && stmt.getFromSource() != null) {

                        Table intoTable = modelManager
                                        .getTableByName(DlineageUtil.getTableIdentityKey(stmt.getTableName().toString()));
                        if (intoTable == null) {
                                intoTable = modelFactory.createTableByName(stmt.getTableName(), false);
                                if (stmt.getColumnList() == null || stmt.getColumnList().size() == 0) {
                                        TObjectName starColumn = DlineageUtil.syntheticStarName();
                                        TableColumn column = modelFactory.createTableColumn(intoTable, starColumn, false);
                                        if (column != null) {
                                                column.setExpandStar(false);
                                                column.setPseduo(true);
                                        }
                                } else {
                                        for (TObjectName columnName : stmt.getColumnList()) {
                                                modelFactory.createTableColumn(intoTable, columnName, true);
                                        }
                                }
                        }
                        Process process = modelFactory.createProcess(stmt);
                        intoTable.addProcess(process);

                        if (stmt.getFromSource() != null) {
                                Table pathModel = modelFactory.createTableByName(stmt.getFromSource(), true);
                                pathModel.setPath(true);
                                pathModel.setCreateTable(true);
                                TObjectName fileUri = new TObjectName();
                                fileUri.setString(stmt.getFromSource());
                                TableColumn fileUriColumn = modelFactory.createFileUri(pathModel, fileUri);
                                if (intoTable != null) {
                                        if (intoTable != null && !intoTable.getColumns().isEmpty()) {
                                                for (int i = 0; i < intoTable.getColumns().size(); i++) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                                        relation.setTarget(new TableColumnRelationshipElement(intoTable.getColumns().get(i)));
                                                        relation.setProcess(process);
                                                }
                                        }
                                }
                        }
                }
        }

        /**
         * SQL Server {@code BULK INSERT <table> FROM '<file>' [WITH (...)]} (Mantis 4962). The file is a path node and its
         * rows reach the table as a whole: one fdd edge from the path's URI to the table's {@code *}, which is never
         * expanded, not even when the table's columns are known, because the statement maps file fields to columns by
         * position or through a format file that is not read. That {@code *} is the table's load column
         * ({@link Table#getLoadColumn()}), no column of the table, so the load changes no other statement's lineage.
         * {@code DATA_SOURCE} names the external data source the path is relative to; it is kept on the path node, and
         * when this analysis met an external data source of that name its LOCATION is joined to the path for the URI;
         * otherwise the URI stays the path as written and an analysis error says the data source was not found.
         */
        private void analyzeMssqlBulkInsertStmt(TMssqlBulkInsert stmt) {
                TObjectName tableName = stmt.getTableName();
                TConstant datafile = stmt.getDatafile();
                if (tableName == null || datafile == null || datafile.toString() == null) {
                        return;
                }
                String literal = datafile.toString().trim();
                if (literal.length() > 1 && (literal.charAt(0) == 'N' || literal.charAt(0) == 'n') && literal.charAt(1) == '\'') {
                        literal = literal.substring(1);
                }
                String file = stringLiteralValue(literal);
                if (SQLUtil.isEmpty(file)) {
                        return;
                }
                Table intoTable = modelFactory.createTableByName(tableName, false);
                if (intoTable == null) {
                        return;
                }
                TableColumn star = intoTable.getLoadColumn();
                if (star == null) {
                        star = new TableColumn(intoTable, DlineageUtil.syntheticStarName());
                        star.setExpandStar(false);
                        star.setPseduo(true);
                        intoTable.setLoadColumn(star);
                }
                Process process = modelFactory.createProcess(stmt);
                intoTable.addProcess(process);

                String dataSource = stmt.getOptionValue("DATA_SOURCE");
                String location = SQLUtil.isEmpty(dataSource) ? null : externalDataSourceLocation(dataSource);
                String uri = location == null ? null : "'" + joinLocation(location, file) + "'";
                boolean template = templatedLoadFiles.containsKey(datafile);
                Table pathModel;
                if (SQLUtil.isEmpty(dataSource) && !template) {
                        pathModel = modelFactory.createTableByName(literal, true);
                } else {
                        // the file's identity: the URI its data source resolves it to, else its text under the data source named
                        // (or under none); a template's text is never a static file of the same text
                        pathModel = modelFactory.createPathModel(literal, Arrays.<Object>asList("BULK INSERT file", template,
                                        uri != null ? uri : file, uri != null || SQLUtil.isEmpty(dataSource) ? null : dataSourceKey(dataSource)));
                }
                // a file is no object of the database a USE names
                pathModel.setPath(true, false);
                pathModel.setCreateTable(true);
                if (template) {
                        pathModel.markDynamicTemplate("name", true);
                        anyDynamicTemplateMarked = true;
                }
                if (!SQLUtil.isEmpty(dataSource)) {
                        pathModel.setDataSourceName(dataSource);
                        if (uri != null) {
                                pathModel.setPathUri(uri);
                        } else {
                                ErrorInfo errorInfo = new ErrorInfo();
                                errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                                errorInfo.setErrorMessage("external data source " + dataSource
                                                + " not found; the BULK INSERT path " + file + " is relative to its LOCATION");
                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(stmt.getStartToken().lineNo,
                                                stmt.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(stmt.getEndToken().lineNo,
                                                stmt.getEndToken().columnNo + stmt.getEndToken().getAstext().length(),
                                                ModelBindingManager.getGlobalHash()));
                                errorInfo.fillInfo(this);
                                errorInfos.add(errorInfo);
                        }
                }
                TObjectName fileUri = new TObjectName();
                fileUri.setString(literal);
                TableColumn fileUriColumn = modelFactory.createFileUri(pathModel, fileUri);

                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                relation.setTarget(new TableColumnRelationshipElement(star));
                relation.setProcess(process);
        }

        /**
         * The identity key an external data source named {@code name} is registered by
         * ({@code ModelFactory.createDataSource}), so the defaults of a USE apply alike. {@code name} is the value of the
         * {@code DATA_SOURCE} string, one stored name: a dot in it qualifies nothing.
         */
        private Object dataSourceKey(String name) {
                IdentifierProfile profile = IdentifierProfile.forVendor(option.getVendor(), IdentifierProfile.VendorFlags.defaults());
                return DlineageUtil.getTableIdentityKey(IdentifierCodec.encodeStored(profile, ESQLDataObjectType.dotTable, name));
        }

        /**
         * The LOCATION of the external data source of this analysis named {@code name} ({@link #dataSourceKey}), the
         * value of its string literal, or null when none was created.
         */
        private String externalDataSourceLocation(String name) {
                Object found = modelManager.getTableByName(dataSourceKey(name));
                if (!(found instanceof Table) || !((Table) found).isDataSource() || ((Table) found).getLocation() == null) {
                        return null;
                }
                String location = ((Table) found).getLocation().trim();
                String value = stringLiteralValue(location.length() > 1 && (location.charAt(0) == 'N' || location.charAt(0) == 'n')
                                && location.charAt(1) == '\'' ? location.substring(1) : location);
                return value != null ? value : location;
        }

        /** The value of a T-SQL string literal {@code '...'}, a doubled quote standing for one; null for any other text. */
        private static String stringLiteralValue(String literal) {
                if (literal == null || literal.length() < 2 || literal.charAt(0) != '\''
                                || literal.charAt(literal.length() - 1) != '\'') {
                        return null;
                }
                return literal.substring(1, literal.length() - 1).replace("''", "'");
        }

        /** {@code location} and {@code path} joined by exactly one '/'. */
        private static String joinLocation(String location, String path) {
                boolean slashBefore = location.endsWith("/") || location.endsWith("\\");
                boolean slashAfter = path.startsWith("/") || path.startsWith("\\");
                if (slashBefore && slashAfter) {
                        return location + path.substring(1);
                }
                if (slashBefore || slashAfter) {
                        return location + path;
                }
                return location + "/" + path;
        }

        private void analyzeCreateIndexExpressionOperand(TExpression expr, Table tableModel){
                if(expr == null) return;
                Deque<TExpression> stack = new ArrayDeque<>();
                stack.push(expr);
                while (!stack.isEmpty()) {
                        TExpression current = stack.pop();
                        if (current == null) continue;
                        TObjectName columnObj = current.getObjectOperand();
                        if (columnObj != null) {
                                TableColumn tableConstraint = modelFactory.createTableColumn(tableModel, columnObj, true);
                                tableConstraint.setIndexKey(true);
                        } else {
                                if (current.getRightOperand() != null) {
                                        stack.push(current.getRightOperand());
                                }
                                if (current.getLeftOperand() != null) {
                                        stack.push(current.getLeftOperand());
                                }
                        }
                }
        }
        private void analyzeCreateIndexStageStmt(TCreateIndexSqlStatement stmt) {
        if(stmt.getTableName() == null){
            return;
        }
                Table tableModel = modelFactory.createTableByName(stmt.getTableName());
                TOrderByItemList columns = stmt.getColumnNameList();
        if(columns!=null) {
            for (int i = 0; i < columns.size(); i++) {
                TExpression expr = columns.getOrderByItem(i).getSortKey();
                analyzeCreateIndexExpressionOperand(expr, tableModel);
            }
        }
        }

        private void analyzeCreateSynonymStmt(TCreateSynonymStmt stmt) {
                TObjectName sourceTableName = stmt.getForName();
                if(sourceTableName == null) {
                        return;
                }
                TCustomSqlStatement createView = viewDDLMap
                                .get(DlineageUtil.getTableIdentityKey(sourceTableName.toString()));
                if (createView != null) {
                        analyzeCustomSqlStmt(createView);
                }
                Table sourceTableModel = modelFactory.createTableByName(sourceTableName);
                Process process = modelFactory.createProcess(stmt);
                sourceTableModel.addProcess(process);
                if(stmt.getSynonymName()!=null) {
                        Table synonymTableModel = modelFactory.createTableByName(stmt.getSynonymName());
                        synonymTableModel.setSubType(SubType.synonym);
                        if(sourceTableModel.isCreateTable()) {
                                synonymTableModel.setCreateTable(true);
                                for(TableColumn sourceTableColumn: new ArrayList<>(sourceTableModel.getColumns())) {
                                        TObjectName columnName = new TObjectName();
                                        columnName.setString(sourceTableColumn.getName());
                                        TableColumn synonymTableColumn = new TableColumn(synonymTableModel, columnName);
                                        synonymTableModel.addColumn(synonymTableColumn);
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(EffectType.create_synonym);
                                        relation.setTarget(new TableColumnRelationshipElement(synonymTableColumn));
                                        relation.addSource(new TableColumnRelationshipElement(sourceTableColumn));
                                        relation.setProcess(process);
                                }
                        }
                        else {
                                TObjectName synonymStarColumn = DlineageUtil.syntheticStarName();
                                TableColumn synonymTableStarColumn = modelFactory.createTableColumn(synonymTableModel,
                                                synonymStarColumn, true);
                                TObjectName sourceStarColumn = DlineageUtil.syntheticStarName();
                                TableColumn sourceTableStarColumn = modelFactory.createTableColumn(sourceTableModel, sourceStarColumn, true);
                                
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.create_synonym);
                                relation.setTarget(new TableColumnRelationshipElement(synonymTableStarColumn));
                                relation.addSource(new TableColumnRelationshipElement(sourceTableStarColumn));
                                relation.setProcess(process);
                        }
                }
        }

        /**
         * For every Table model that maps to a {@link TSQLSynonyms} in the current
         * {@link #sqlenv}, materialize the synonym's base table as a separate Table
         * model and emit per-column {@code fdd}/{@code synonym} relations from the
         * synonym's columns to the base table's matching columns. Lets lineage flow
         * through synonyms defined in the metadata SQLEnv (e.g. loaded via
         * {@code TDDLSQLEnv} or sqlflow metadata) the same way it does for
         * {@code CREATE SYNONYM} DDL inside the analyzed script.
         */
        /**
         * The identity of a catalog synonym under the analysis's identifier rules, in the synonym role, from the stored
         * names the catalog holds; a tier the catalog holds only as its placeholder is left out, as a table model leaves
         * it out. Null when the rules give the name no identity.
         */
        private static QualifiedCanonKey storedSynonymIdentity(IdentifierService service, TSQLCatalog catalog,
                        TSQLSchema schema, TSQLSynonyms synonym) {
                if (service == null) {
                        return null;
                }
                EDbVendor vendor = service.getProfile().getVendor();
                List<String> segments = new ArrayList<String>();
                if (TSQLEnv.supportCatalog(vendor) && catalog.getName() != null
                                && !TSQLEnv.DEFAULT_DB_NAME.equalsIgnoreCase(catalog.getName())) { // non-identifier-compare: DEFAULT is the placeholder for a missing tier
                        segments.add(catalog.getName());
                }
                if (TSQLEnv.supportSchema(vendor) && schema.getName() != null
                                && !TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(schema.getName())) { // non-identifier-compare: DEFAULT is the placeholder for a missing tier
                        segments.add(schema.getName());
                }
                segments.add(synonym.getName());
                try {
                        return service.qualifiedCanonKeyFromStored(segments, ESQLDataObjectType.dotSynonyms);
                } catch (RuntimeException noIdentity) {
                        return null;
                }
        }

        private void materializeSqlEnvSynonyms() {
                if (sqlenv == null) {
                        return;
                }
                List<Table> snapshot = new ArrayList<Table>(modelManager.getTablesByName());

                // Catalog synonyms by identity under the analysis's rules, from the names the catalog stores, in the
                // synonym role (a profile may give synonyms rules of their own). A model matches by its identity in that
                // role, never by its rendered name: a stored lower-case Oracle synonym is the quoted name
                // "address_synonym", which a folded rendering reads as ADDRESS_SYNONYM.
                Map<QualifiedCanonKey, TSQLSynonyms> synonymsByIdentity = new HashMap<>();
                IdentifierService synonymService = ModelBindingManager.getGlobalIdentifierService();
                List<TSQLCatalog> catalogs = sqlenv.getCatalogList();
                if (catalogs != null) {
                        for (TSQLCatalog catalog : catalogs) {
                                if (catalog == null) {
                                        continue;
                                }
                                List<TSQLSchema> schemas = catalog.getSchemaList();
                                if (schemas == null) {
                                        continue;
                                }
                                for (TSQLSchema schema : schemas) {
                                        if (schema == null) {
                                                continue;
                                        }
                                        List<TSQLSchemaObject> schemaObjects = schema.getSchemaObjectList();
                                        if (schemaObjects == null || schemaObjects.isEmpty()) {
                                                continue;
                                        }
                                        for (TSQLSchemaObject schemaObject : schemaObjects) {
                                                if (schemaObject instanceof TSQLSynonyms) {
                                                        TSQLSynonyms synonym = (TSQLSynonyms) schemaObject;
                                                        QualifiedCanonKey identity = storedSynonymIdentity(synonymService, catalog, schema, synonym);
                                                        if (identity != null) {
                                                                synonymsByIdentity.put(identity, synonym);
                                                        }
                                                }
                                        }
                                }
                        }
                }

                for (Table synonymTableModel : snapshot) {
                        if (synonymTableModel == null) {
                                continue;
                        }
                        if (SubType.synonym.equals(synonymTableModel.getSubType())) {
                                continue;
                        }
                        QualifiedCanonKey modelIdentity = synonymTableModel.getCanonicalIdentityAs(ESQLDataObjectType.dotSynonyms);
                        TSQLSynonyms synonym = modelIdentity == null ? null : synonymsByIdentity.get(modelIdentity);
                        if (synonym == null) {
                                continue;
                        }

                        String baseSqlTableQualifiedName = synonym.getBaseTableQualifiedName();
                        if (baseSqlTableQualifiedName == null) {
                                continue;
                        }

                        synonymTableModel.setSubType(SubType.synonym);

                        // The base table is named by the catalog, not by the SQL, so no position of it is published: a model made
                        // from a synthesized TObjectName would claim the name's own position (line 1), and that path also stamps
                        // the position onto a table the SQL did reference.
                        Table baseTableModel = modelFactory.createCatalogNamedTable(baseSqlTableQualifiedName);
                        if (baseTableModel == null || baseTableModel == synonymTableModel) {
                                continue;
                        }

                        for (TableColumn synonymColumn : new ArrayList<TableColumn>(synonymTableModel.getColumns())) {
                                String colName = synonymColumn.getName();
                                if (SQLUtil.isEmpty(colName) || synonymColumn.isStarColumn()) {
                                        continue;
                                }
                                TableColumn baseColumn = null;
                                for (TableColumn bc : baseTableModel.getColumns()) {
                                        if (bc.getName() != null && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, bc.getName(), colName)) {
                                                baseColumn = bc;
                                                break;
                                        }
                                }
                                if (baseColumn == null) {
                                        TObjectName columnName = new TObjectName();
                                        columnName.setString(colName);
                                        baseColumn = new TableColumn(baseTableModel, columnName);
                                        // a column the catalog relates to the synonym, not a name the SQL wrote: no position
                                        baseColumn.setStartPosition(null);
                                        baseColumn.setEndPosition(null);
                                        baseTableModel.addColumn(baseColumn);
                                }
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.synonym);
                                relation.setTarget(new TableColumnRelationshipElement(synonymColumn));
                                relation.addSource(new TableColumnRelationshipElement(baseColumn));
                        }
                }
        }

        private void analyzeRenameStmt(TRenameStmt stmt) {
                TObjectName oldTableName = stmt.getOldName();
                TObjectName newTableName = stmt.getNewName();
                
                Table oldNameTableModel = modelFactory.createTableByName(oldTableName);
                TObjectName oldStarColumn = DlineageUtil.syntheticStarName();
                TableColumn oldTableStarColumn = modelFactory.createTableColumn(oldNameTableModel, oldStarColumn, true);
                
                Table newNameTableModel = modelFactory.createTableByName(newTableName);
                TObjectName newStarColumn = DlineageUtil.syntheticStarName();
                TableColumn newTableStarColumn = modelFactory.createTableColumn(newNameTableModel, newStarColumn, true);
                
                Process process = modelFactory.createProcess(stmt);
                newNameTableModel.addProcess(process);
                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType( EffectType.rename_table);
                relation.setTarget(new TableColumnRelationshipElement(newTableStarColumn));
                relation.addSource(new TableColumnRelationshipElement(oldTableStarColumn));
                relation.setProcess(process);
                
                if ((oldNameTableModel.isCreateTable() || oldNameTableModel.hasSQLEnv())) {
                        oldTableStarColumn.setShowStar(false);
                        relation.setShowStarRelation(false);
                }

                if ((newNameTableModel.isCreateTable() || newNameTableModel.hasSQLEnv())) {
                        newTableStarColumn.setShowStar(false);
                        relation.setShowStarRelation(false);
                }
        }
        
        /**
         * {@code ALTER TABLE source SWITCH [PARTITION p] TO target [PARTITION q]} (SQL Server, OpenEdge): the rows move
         * from the altered table, or one of its partitions, into the target, so data flows one way, source -> target
         * ({@code EXCHANGE PARTITION} swaps, hence its two relations). With every column of both tables known (a CREATE
         * TABLE or a SELECT ... INTO in the script, or metadata) each column flows into its namesake, paired by the
         * identifier rules. Else the relation is source.* -> target.*: the star expansion resolves it by the side whose
         * columns are known (SWITCH requires the same columns on both), and with neither known it stays table level. That
         * relation's partition is the source partition when the statement names one, which is what
         * {@code exchange_partition} records too: the partition of the altered table.
         */
        private void analyzeSwitchPartition(TAlterTableStatement stmt, TAlterTableOption option, Table sourceModel,
                        TableColumn sourceStarColumn) {
                TObjectName targetName = option.getNewTableName();
                if (targetName == null) {
                        return;
                }
                Table targetModel = null;
                Stack<TParseTreeNode> nodes = targetName.getStartToken().getNodesStartFromThisToken();
                for (int j = 0; nodes != null && j < nodes.size(); j++) {
                        if (nodes.get(j) instanceof TTable) {
                                targetModel = modelFactory.createTable((TTable) nodes.get(j));
                                break;
                        }
                }
                if (targetModel == null) {
                        targetModel = modelFactory.createTableByName(targetName);
                }
                targetModel.setStarStmt("switch_partition");

                // The star expansion goes by the columns' text and loses a real column named * (a delimited [*]): pair the
                // columns here when both tables' columns are known. Like the pairs a star expands to (exchange_partition's
                // too), a pair carries no partition; the table-level relation does.
                List<TableColumn> sourceColumns = switchColumns(sourceModel);
                List<TableColumn> targetColumns = switchColumns(targetModel);
                if (sourceColumns != null && targetColumns != null) {
                        sourceStarColumn.setShowStar(false);
                        Process process = modelFactory.createProcess(stmt);
                        targetModel.addProcess(process);
                        for (TableColumn sourceColumn : sourceColumns) {
                                TableColumn targetColumn = namesake(sourceColumn, targetColumns);
                                if (targetColumn == null) {
                                        continue;   // the tables' columns disagree: a column the target does not have is not invented
                                }
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.switch_partition);
                                relation.setTarget(new TableColumnRelationshipElement(targetColumn));
                                relation.addSource(new TableColumnRelationshipElement(sourceColumn));
                                relation.setProcess(process);
                        }
                        return;
                }

                TableColumn targetStarColumn = modelFactory.createTableColumn(targetModel, DlineageUtil.syntheticStarName(),
                                true);
                Process process = modelFactory.createProcess(stmt);
                targetModel.addProcess(process);
                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(EffectType.switch_partition);
                relation.setTarget(new TableColumnRelationshipElement(targetStarColumn));
                relation.addSource(new TableColumnRelationshipElement(sourceStarColumn));
                relation.setProcess(process);
                TExpression sourcePartition = switchSourcePartition(option, targetName);
                if (sourcePartition != null) {
                        relation.setPartition(sourcePartition.toString());
                }
                if (sourceModel.isCreateTable() || sourceModel.hasSQLEnv()) {
                        sourceStarColumn.setShowStar(false);
                        relation.setShowStarRelation(false);
                }
                if (targetModel.isCreateTable() || targetModel.hasSQLEnv()) {
                        targetStarColumn.setShowStar(false);
                        relation.setShowStarRelation(false);
                }
        }

        /**
         * The partition of the SWITCH source, or null. The parser keeps the partition expressions in the order they
         * appear ({@code SWITCH TO t PARTITION n} stores the TARGET partition first), so the source partition is the one
         * written before the target table's name.
         */
        private static TExpression switchSourcePartition(TAlterTableOption option, TObjectName targetName) {
                TSourceToken targetStart = targetName.getStartToken();
                for (TExpression partition : new TExpression[] { option.getPartitionExpression1(), option.getPartitionExpression2() }) {
                        if (partition != null && partition.getStartToken() != null && targetStart != null
                                        && partition.getStartToken().posinlist < targetStart.posinlist) {
                                return partition;
                        }
                }
                return null;
        }

        /**
         * The columns of a SWITCH table when the analysis knows every one of them -- declared by a CREATE TABLE in the
         * script, given by metadata, or made by a SELECT ... INTO whose columns are all known -- stars and system pseudo
         * columns left out; null when it does not: a table only referenced (an INSERT without a column list marks its
         * target determined, yet names only the columns it writes), a SELECT ... INTO with a * the analysis could not
         * expand (whatever a later INSERT makes of the table), metadata with a star it could not resolve (a table
         * determined all the same), a table without columns.
         */
        private List<TableColumn> switchColumns(Table table) {
                boolean selectInto = table.getEndpointIntroduction() == EndpointIntroduction.SELECT_INTO;
                if (!table.isDetermined() || !(table.isCreateTable() || table.hasSQLEnv() || selectInto)
                                || (selectInto && selectIntoWithUnknownColumns.contains(table)) || metadataHoldsUnresolvedStar(table)) {
                        return null;
                }
                List<TableColumn> columns = new ArrayList<TableColumn>();
                for (TableColumn column : table.getColumns()) {
                        if (!column.isStarColumn() && !column.isPseduo()) {
                                columns.add(column);
                        }
                }
                return columns.isEmpty() ? null : columns;
        }

        /**
         * SELECT ... INTO targets some SELECT ... INTO did not name every column of (a * the analysis could not expand),
         * by identity: whether the SELECT named them all is the SELECT's own fact, where the target's being determined can
         * change after it -- an INSERT without a column list marks its target determined -- and GSP keeps such a * in the
         * target either as a star or as a column named *.
         */
        private final Set<Table> selectIntoWithUnknownColumns = Collections.newSetFromMap(new IdentityHashMap<Table, Boolean>());

        /** Records whether a SELECT ... INTO named every column of its target; once one did not, the table stays so. */
        private void recordSelectIntoColumns(Table target, boolean allNamed) {
                if (!allNamed) {
                        selectIntoWithUnknownColumns.add(target);
                }
        }

        /**
         * The SELECT ... INTO statement that first made each table, by identity. A DROP ends a table and the next
         * SELECT ... INTO makes a new one, so a second statement making the same table is an alternative to the first,
         * as in the two branches of an IF.
         */
        private final Map<Table, TSelectSqlStatement> selectIntoDefinitions = new IdentityHashMap<Table, TSelectSqlStatement>();

        /**
         * Records what a SELECT ... INTO tells of its target's columns, and marks the target a table whose columns are
         * exactly the ones the SELECT named when that is known, so that a later {@code SELECT *} of it expands to them and
         * an INSERT column list pairs with them by position (Mantis 4753). That holds when the SELECT named every column,
         * the statement creates the table ({@link #selectIntoFixesColumns}) and it is the table's only SELECT ... INTO.
         * Two statements making one table ({@code IF ... SELECT a, b INTO #t ... ELSE SELECT c INTO #t}) leave the
         * columns to the branch that ran, while the model holds the columns of both, which no run has.
         */
        private void recordSelectIntoTarget(TSelectSqlStatement stmt, Table tableModel, TObjectName tableName,
                        boolean allNamed, List<TableColumn> written) {
                recordSelectIntoColumns(tableModel, allNamed);
                if (tableModel.isVariable()) {
                        // a variable is assigned, not made, as often as the code does
                        if (allNamed && DlineageUtil.isTempTable(tableModel, option.getVendor())) {
                                tableModel.setCreateTable(true, false);
                        }
                        return;
                }
                if (!selectIntoFixesColumns(tableModel, tableName)) {
                        recordPermanentSelectInto(stmt, tableModel, written);
                        return;
                }
                TSelectSqlStatement first = selectIntoDefinitions.get(tableModel);
                if (first == null) {
                        selectIntoDefinitions.put(tableModel, stmt);
                } else if (first != stmt) {
                        recordSelectIntoColumns(tableModel, false);
                        if (tableModel.isCreateTable()) {
                                tableModel.setCreateTable(false, false);
                        }
                }
                if (!selectIntoWithUnknownColumns.contains(tableModel)) {
                        tableModel.setCreateTable(true, false);
                }
        }

        /**
         * The columns of a permanent table, in order, as the only SELECT ... INTO that made it wrote them, by identity;
         * gone once a second SELECT ... INTO makes the table or an ALTER TABLE changes it.
         */
        private final Map<Table, List<TableColumn>> selectIntoColumnLists = new IdentityHashMap<Table, List<TableColumn>>();

        /**
         * Records the columns a SELECT ... INTO wrote into a permanent table, {@code written} in select-list order, or
         * null when they are not all known. The table is not marked created, as a temporary one is: a permanent table can
         * gain columns from code the analysis never reads, and a created table drops a reference to a column it lacks.
         */
        private void recordPermanentSelectInto(TSelectSqlStatement stmt, Table tableModel, List<TableColumn> written) {
                recordSelectIntoAlternative(stmt, tableModel, written);
                TSelectSqlStatement first = selectIntoDefinitions.get(tableModel);
                if (first == null) {
                        selectIntoDefinitions.put(tableModel, stmt);
                        if (written != null) {
                                selectIntoColumnLists.put(tableModel, new ArrayList<TableColumn>(written));
                        }
                } else if (first != stmt || written == null) {
                        selectIntoColumnLists.remove(tableModel);
                }
        }

        /**
         * The columns each SELECT ... INTO that made a permanent table wrote, in select-list order, by statement identity;
         * null for one whose columns are not all known. Gone once an ALTER TABLE changes the table (Mantis 4860).
         */
        private final Map<Table, List<Pair<TSelectSqlStatement, List<TableColumn>>>> selectIntoAlternatives =
                        new IdentityHashMap<Table, List<Pair<TSelectSqlStatement, List<TableColumn>>>>();

        /** Records the columns {@code stmt} wrote into the permanent table {@code tableModel}, or null when not all are known. */
        private void recordSelectIntoAlternative(TSelectSqlStatement stmt, Table tableModel, List<TableColumn> written) {
                List<Pair<TSelectSqlStatement, List<TableColumn>>> definitions = selectIntoAlternatives.get(tableModel);
                if (definitions == null) {
                        definitions = new ArrayList<Pair<TSelectSqlStatement, List<TableColumn>>>();
                        selectIntoAlternatives.put(tableModel, definitions);
                }
                Pair<TSelectSqlStatement, List<TableColumn>> definition = new Pair<TSelectSqlStatement, List<TableColumn>>(stmt,
                                written == null ? null : new ArrayList<TableColumn>(written));
                for (int i = 0; i < definitions.size(); i++) {
                        if (definitions.get(i).first == stmt) {
                                definitions.set(i, definition);
                                return;
                        }
                }
                definitions.add(definition);
        }

        /**
         * The column lists, in order, of the SELECT ... INTO statements that made the permanent table {@code table}, when
         * there are two or more, all complete and as wide (Mantis 4860, owner decision 2026-10-22): which one made the table
         * is not known, so a {@code SELECT *} of it reads, at each position, the column each of them wrote there. Null
         * otherwise, or while the table has a column none of them wrote, as {@link #starExpansionColumns} has it.
         */
        private List<List<TableColumn>> starAlternatives(Table table) {
                List<Pair<TSelectSqlStatement, List<TableColumn>>> definitions = selectIntoAlternatives.get(table);
                if (definitions == null || definitions.size() < 2 || table.isCreateTable() || !table.isDetermined()
                                || selectIntoWithUnknownColumns.contains(table)) {
                        return null;
                }
                List<List<TableColumn>> lists = new ArrayList<List<TableColumn>>();
                List<TableColumn> written = new ArrayList<TableColumn>();
                for (Pair<TSelectSqlStatement, List<TableColumn>> definition : definitions) {
                        List<TableColumn> columns = definition.second;
                        if (columns == null || columns.isEmpty() || !lists.isEmpty() && columns.size() != lists.get(0).size()) {
                                return null;
                        }
                        lists.add(columns);
                        written.addAll(columns);
                }
                Set<TableColumn> members = Collections.newSetFromMap(new IdentityHashMap<TableColumn, Boolean>());
                members.addAll(written);
                for (TableColumn column : table.getColumns()) {
                        if (!column.isStarColumn() && !column.isPseduo() && !members.contains(column)
                                        && namesake(column, written) == null) {
                                return null;
                        }
                }
                return lists;
        }

        /** Whether {@code resultSet} has a column of the name {@code name}. */
        private boolean namedIn(ResultSet resultSet, String name) {
                for (ResultColumn column : resultSet.getColumns()) {
                        if (SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, column.getName(), name)) {
                                return true;
                        }
                }
                return false;
        }

        /**
         * A reference by name to a column of the derived table {@code table} that its alias list does not name (Mantis 4873),
         * where the list may be shorter than the query ({@link #columnListMayBeShorter}): a column past the list keeps its
         * name. A reference names its column; no position is assumed, so a SELECT * of the derived table or a list it fills
         * is not affected.
         */
        private void readPastAliasList(TTable table, TObjectName columnName, AbstractRelationship relation) {
                if (!columnListMayBeShorter(option.getVendor()) || table.getSubquery() == null
                                || table.getAliasClause() == null || table.getAliasClause().getColumns() == null
                                || !(modelManager.getModel(table.getSubquery()) instanceof ResultSet)) {
                        return;
                }
                List<ResultColumn> query = ((ResultSet) modelManager.getModel(table.getSubquery())).getColumns();
                int listed = table.getAliasClause().getColumns().size();
                // the column of the query named so; the output publishes the columns of one name in a select as one column, so
                // with two of them what the name reads is not told apart
                int named = -1;
                for (int j = 0; j < query.size(); j++) {
                        if (!query.get(j).isStarColumn() && referencesColumn(columnName, query.get(j))) {
                                if (named >= 0) {
                                        return;
                                }
                                named = j;
                        }
                }
                boolean starBefore = false;
                for (int j = 0; j < named; j++) {
                        starBefore |= query.get(j).isStarColumn();
                }
                // past the list wherever the stars before it end; after a star it may stand there too; else the list renames it
                boolean past = named >= listed;
                if (past || (named >= 0 && starBefore)) {
                        readQueryColumn(query.get(named), listed, columnName, relation);
                }
                // the stars that may stand for a column of the name past the list. PostgreSQL rejects a read of a name two columns
                // past the list have: none where the column stands past the list, else those after it (one before it reaching
                // past the list would put it there too). DuckDB names the later ones past the list k_1 (Codex review): those
                // before the column where it stands past the list, else all of them
                boolean duckdb = option.getVendor() == EDbVendor.dbvduckdb;
                if (past && !duckdb) {
                        return;
                }
                // the output publishes a star's column of the name as the column named so: only where that one names the same column
                if (named >= 0 && !plainReference(query.get(named))) {
                        return;
                }
                int from = duckdb ? 0 : named + 1;
                int to = duckdb && past ? named : query.size();
                for (int j = from; j < to; j++) {
                        if (query.get(j).isStarColumn() && !starOmits(query.get(j), columnName)) {
                                readThroughStar(query.get(j), columnName, relation);
                        }
                }
        }

        /** Whether {@code column} is a select item that names a column, without an alias. */
        private static boolean plainReference(ResultColumn column) {
                if (!(column.getColumnObject() instanceof TResultColumn)) {
                        return false;
                }
                TResultColumn item = (TResultColumn) column.getColumnObject();
                return item.getAliasClause() == null && item.getExpr() != null
                                && item.getExpr().getExpressionType() == EExpressionType.simple_object_name_t;
        }

        /**
         * Reads {@code column} of the query of a derived table past its alias list of {@code listed} names: a column of a set
         * operation reads the columns of its selects that can stand past the list, leaving out one its select puts within
         * the list whatever its stars stand for (Codex review).
         */
        private void readQueryColumn(ResultColumn column, int listed, TObjectName columnName, AbstractRelationship relation) {
                List<ResultColumn> selects = setColumnSources.get(column);
                if (selects != null) {
                        List<ResultColumn> past = new ArrayList<ResultColumn>();
                        for (ResultColumn select : selects) {
                                if (!standsWithin(select, listed)) {
                                        past.add(select);
                                }
                        }
                        if (past.size() < selects.size()) {
                                for (ResultColumn select : past) {
                                        relation.addSource(new ResultColumnRelationshipElement(select));
                                }
                                return;
                        }
                }
                // the column itself: read by name, the output could take another column of the name for it
                relation.addSource(new ResultColumnRelationshipElement(column));
        }

        /** Whether {@code column} stands at one of the first {@code listed} positions of its select, with no star before it. */
        private static boolean standsWithin(ResultColumn column, int listed) {
                List<ResultColumn> columns = column.getResultSet() == null ? null : column.getResultSet().getColumns();
                for (int i = 0; columns != null && i < columns.size() && i < listed; i++) {
                        if (columns.get(i) == column) {
                                return true;
                        }
                        if (columns.get(i).isStarColumn()) {
                                return false;
                        }
                }
                return false;
        }

        /** Whether the star item {@code star} leaves the column {@code name} out or replaces it (EXCEPT, REPLACE). */
        private static boolean starOmits(ResultColumn star, TObjectName name) {
                if (!(star.getColumnObject() instanceof TResultColumn)) {
                        return false;
                }
                TResultColumn item = (TResultColumn) star.getColumnObject();
                if (item.getExceptColumnList() != null) {
                        for (TObjectName except : item.getExceptColumnList()) {
                                if (DlineageUtil.sameColumnName(except, name)) {
                                        return true;
                                }
                        }
                }
                if (item.getReplaceExprAsIdentifiers() != null) {
                        for (TReplaceExprAsIdentifier replace : item.getReplaceExprAsIdentifiers()) {
                                if (DlineageUtil.sameColumnName(replace.getIdentifier(), name)) {
                                        return true;
                                }
                        }
                }
                return false;
        }

        /** {@code columnName} read through {@code star}: the column of that name the star stands for. */
        private void readThroughStar(ResultColumn star, TObjectName columnName, AbstractRelationship relation) {
                if (!containsStarColumn(star, columnName)) {
                        star.bindStarLinkColumn(columnName);
                }
                relation.addSource(new ResultColumnRelationshipElement(star, columnName));
        }

        /** A column of {@code queryTable}, a derived table, past its alias list: the query's {@code sourceColumn} under its own name. */
        private void derivedColumnPastList(QueryTable queryTable, ResultColumn sourceColumn) {
                ResultColumn targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(EffectType.select);
                relation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                relation.addSource(new ResultColumnRelationshipElement(sourceColumn));
        }

        /** Whether {@code stmt} is the query an INSERT writes, whose columns the INSERT reads by position. */
        private static boolean isInsertSubquery(TSelectSqlStatement stmt) {
                return stmt.getParentStmt() instanceof TInsertSqlStatement
                                && ((TInsertSqlStatement) stmt.getParentStmt()).getSubQuery() == stmt;
        }

        /**
         * The columns a {@code SELECT *} of {@code table} expands to, in order, or null when they are not known: a created
         * table's columns, or the columns the only SELECT ... INTO of a permanent table wrote, in its select-list order,
         * while every column of the table is one of them or of the same name (an INSERT into the table writes rows, not
         * columns). A column of another name, which a later statement read, leaves the order unproven (Mantis 4856).
         */
        private List<TableColumn> starExpansionColumns(Table table) {
                if (table.isCreateTable()) {
                        return table.getColumns();
                }
                List<TableColumn> written = selectIntoColumnLists.get(table);
                if (written == null || written.isEmpty() || !table.isDetermined()
                                || selectIntoWithUnknownColumns.contains(table)) {
                        return null;
                }
                Set<TableColumn> members = Collections.newSetFromMap(new IdentityHashMap<TableColumn, Boolean>());
                members.addAll(written);
                int present = 0;
                for (TableColumn column : table.getColumns()) {
                        if (column.isStarColumn() || column.isPseduo()) {
                                continue;
                        }
                        if (members.contains(column)) {
                                present++;
                        } else if (namesake(column, written) == null) {
                                return null;
                        }
                }
                return present == written.size() ? written : null;
        }

        /**
         * The source element of {@code column} at a position of a list of targets (INSERT, CREATE TABLE ... AS, a view's or
         * a CTE's column list): a star of unknown column order ({@link #unknownOrderStar}) is read whole, never by the member
         * named like the target or standing at its ordinal (Mantis 4860, owner ruling 2026-10-03), as Mantis 4856 reads one
         * in an INSERT column list ({@link #insertListSource}). Any other column keeps its element.
         */
        private ResultColumnRelationshipElement positionSource(ResultColumn column) {
                ResultColumnRelationshipElement source = new ResultColumnRelationshipElement(column);
                if (unknownOrderStar(column)) {
                        source.setPositionUnproven(true);
                }
                return source;
        }

        /**
         * Whether {@code column} is a star whose members only other statements name, over one table that proves no column
         * order: the table has a star of its own, and a table the script creates (CREATE TABLE ... AS, SELECT ... INTO)
         * starts with it ({@code CREATE TABLE q AS SELECT k AS p, *} proves q.p first). A member its own statement names
         * keeps its pairing (owner decision 2026-10-22, {@code WHERE sender = '1'}). Not a variable (a record SELECT ...
         * INTO fills), which the simple output leaves out, nor a star with EXCEPT or REPLACE.
         */
        private boolean unknownOrderStar(ResultColumn column) {
                List<Object> tables = column.isStarColumn() && !linkedInItsStatement(column) ? starTableModels(column) : null;
                if (tables == null || tables.size() != 1) {
                        return false;
                }
                Table table = (Table) tables.get(0);
                if (table.isVariable() || !containStarColumn(table.getColumns())) {
                        return false;
                }
                if (table.isCreatedInSql()) {
                        // the columns of a table the script creates stand in its select list's order
                        for (TableColumn tableColumn : table.getColumns()) {
                                if (!tableColumn.isPseduo()) {
                                        return tableColumn.isStarColumn();
                                }
                        }
                }
                return true;
        }

        /**
         * Whether a name the star {@code column} links is written in the statement being analyzed, the star's own: the
         * names of other statements that a set operation's star carries say nothing of the order. Without a token or a
         * statement to tell, a name counts as the statement's own.
         */
        private boolean linkedInItsStatement(ResultColumn column) {
                if (!column.hasStarLinkColumn()) {
                        return false;
                }
                TCustomSqlStatement statement = stmtStack.isEmpty() ? null : stmtStack.firstElement();
                TSourceToken start = statement == null ? null : statement.getStartToken();
                TSourceToken end = statement == null ? null : statement.getEndToken();
                for (TObjectName link : column.getStarLinkColumnList()) {
                        TSourceToken token = link.getStartToken();
                        if (start == null || end == null || token == null || token.container == start.container
                                        && token.posinlist >= start.posinlist && token.posinlist <= end.posinlist) {
                                return true;
                        }
                }
                return false;
        }

        /**
         * The source of an INSERT column-list target the column {@code resultColumn} of {@code subquery} feeds. A star
         * whose members the analysis does not know reads them in an unknown order, so no member is the one at the target's
         * position: the target reads the star, never a member named like the target (Mantis 4856), when the star's one
         * table has a star of its own for it to read.
         */
        private ResultColumnRelationshipElement insertListSource(ResultColumn resultColumn, TSelectSqlStatement subquery) {
                ResultColumnRelationshipElement source = new ResultColumnRelationshipElement(resultColumn);
                if (!resultColumn.isStarColumn() || resultColumn.hasStarLinkColumn()
                                || subquery.getSetOperatorType() != ESetOperatorType.none
                                || !(resultColumn.getColumnObject() instanceof TResultColumn)) {
                        return source;
                }
                TObjectName star = ((TResultColumn) resultColumn.getColumnObject()).getFieldAttr();
                List<TTable> tables = star == null ? null : star.getSourceTableList();
                Object model = tables == null || tables.size() != 1 ? null : modelManager.getModel(tables.get(0));
                // a variable (a record SELECT ... INTO fills in PostgreSQL or Oracle) is left out of the simple output, so a
                // target reading only its * would lose its upstream there
                if (model instanceof Table && !((Table) model).isVariable() && containStarColumn(((Table) model).getColumns())) {
                        source.setPositionUnproven(true);
                }
                return source;
        }

        /**
         * Whether a SELECT ... INTO {@code tableName} creates a table that only the analyzed code can change: a
         * transient temporary table, {@code INTO #t} or {@code INTO TEMP t}, by the rule resolver2 registers it with
         * ({@link TemporaryTableSemantics#ofSelectInto}). A permanent table, or a global {@code ##t} other sessions see,
         * may be altered by code the analysis never reads. {@link DlineageUtil#isTempTable} knows only SQL Server's
         * {@code #t}, and must stay so: it also drops a table when its routine ends, which a SAP IQ {@code #} table
         * outlives (Mantis 4715).
         */
        private boolean selectIntoFixesColumns(Table tableModel, TObjectName tableName) {
                return DlineageUtil.isTempTable(tableModel, option.getVendor()) || TemporaryTableSemantics
                                .isTransient(TemporaryTableSemantics.ofSelectInto(option.getVendor(), tableName));
        }

        /** Whether the metadata describes {@code table} with a star it could not resolve, so not every column is known. */
        private static boolean metadataHoldsUnresolvedStar(Table table) {
                TSQLEnv sqlEnv = ModelBindingManager.getGlobalSQLEnv();
                TSQLTable metadata = sqlEnv == null ? null : sqlEnv.searchTable(ModelFactory.getQualifiedTableName(table));
                if (metadata == null || metadata.getColumnList() == null) {
                        return false;
                }
                for (TSQLColumn column : metadata.getColumnList()) {
                        if (column.isUnresolvedStar()) {
                                return true;
                        }
                }
                return false;
        }

        /** The column of {@code columns} that is {@code column} under the identifier rules, or null. */
        private static TableColumn namesake(TableColumn column, List<TableColumn> columns) {
                for (TableColumn candidate : columns) {
                        boolean same = column.getIdentifierKey() != null && candidate.getIdentifierKey() != null
                                        ? column.getIdentifierKey().equals(candidate.getIdentifierKey())
                                        // names that are no identifier (a STRUCT path) compare as column paths, as matching a reference does
                                        : DlineageUtil.sameColumnPath(column.getName(), candidate.getName());
                        if (same) {
                                return candidate;
                        }
                }
                return null;
        }

        private void analyzeAlterTableStmt(TAlterTableStatement stmt) {
                TTable oldNameTable = stmt.getTargetTable();
                if (oldNameTable == null) {
                        return;
                }

                Table oldNameTableModel = modelFactory.createTable(oldNameTable);
                // an ALTER can drop, add or reorder columns, so the SELECT ... INTO's column order no longer holds
                selectIntoColumnLists.remove(oldNameTableModel);
                selectIntoAlternatives.remove(oldNameTableModel);
                TObjectName oldStarColumn = DlineageUtil.syntheticStarName();
                TableColumn oldTableStarColumn = modelFactory.createTableColumn(oldNameTableModel, oldStarColumn, true);

                for (int i = 0; stmt.getAlterTableOptionList() != null && i < stmt.getAlterTableOptionList().size(); i++) {
                        TAlterTableOption option = stmt.getAlterTableOptionList().getAlterTableOption(i);
                        if (option.getOptionType() == EAlterTableOptionType.RenameTable
                                        || option.getOptionType() == EAlterTableOptionType.swapWith) {
                                TObjectName newTableName = option.getNewTableName();
                                Stack<TParseTreeNode> list = newTableName.getStartToken().getNodesStartFromThisToken();
                                boolean containsTable = false;
                                for (int j = 0; j < list.size(); j++) {
                                        if (list.get(j) instanceof TTable) {
                                                TTable newTableTable = (TTable) list.get(j);
                                                Table newNameTableModel = modelFactory.createTable(newTableTable);
                                                newNameTableModel.setStarStmt("rename_table");

                                                TObjectName newStarColumn = DlineageUtil.syntheticStarName();
                                                TableColumn newTableStarColumn = modelFactory.createTableColumn(newNameTableModel,
                                                                newStarColumn, true);

                                                Process process = modelFactory.createProcess(stmt);
                                                newNameTableModel.addProcess(process);
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(
                                                                option.getOptionType() == EAlterTableOptionType.RenameTable ? EffectType.rename_table
                                                                                : EffectType.swap_table);                                               
                                                if (option.getOptionType() == EAlterTableOptionType.RenameTable) {
                                                        relation.setTarget(new TableColumnRelationshipElement(newTableStarColumn));
                                                        relation.addSource(new TableColumnRelationshipElement(oldTableStarColumn));
                                                } else if (option.getOptionType() == EAlterTableOptionType.swapWith) {
                                                        relation.setTarget(new TableColumnRelationshipElement(oldTableStarColumn));
                                                        relation.addSource(new TableColumnRelationshipElement(newTableStarColumn));
                                                }
                                                relation.setProcess(process);
                                                containsTable = true;

                                                if ((oldNameTableModel.isCreateTable() || oldNameTableModel.hasSQLEnv())) {
                                                        oldTableStarColumn.setShowStar(false);
                                                        relation.setShowStarRelation(false);
                                                }

                                                if ((newNameTableModel.isCreateTable() || newNameTableModel.hasSQLEnv())) {
                                                        newTableStarColumn.setShowStar(false);
                                                        relation.setShowStarRelation(false);
                                                }
                                        }
                                }
                                if (!containsTable) {
                                        Table newNameTableModel = modelFactory.createTableByName(newTableName);
                                        newNameTableModel.setStarStmt("rename_table");
                                        TObjectName newStarColumn = DlineageUtil.syntheticStarName();
                                        TableColumn newTableStarColumn = modelFactory.createTableColumn(newNameTableModel, newStarColumn,
                                                        true);

                                        Process process = modelFactory.createProcess(stmt);
                                        newNameTableModel.addProcess(process);
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(
                                                        option.getOptionType() == EAlterTableOptionType.RenameTable ? EffectType.rename_table
                                                                        : EffectType.swap_table);
                                        if (option.getOptionType() == EAlterTableOptionType.RenameTable) {
                                                relation.setTarget(new TableColumnRelationshipElement(newTableStarColumn));
                                                relation.addSource(new TableColumnRelationshipElement(oldTableStarColumn));
                                        } else if (option.getOptionType() == EAlterTableOptionType.swapWith) {
                                                relation.setTarget(new TableColumnRelationshipElement(oldTableStarColumn));
                                                relation.addSource(new TableColumnRelationshipElement(newTableStarColumn));
                                        }
                                        relation.setProcess(process);
                                        if ((oldNameTableModel.isCreateTable() || oldNameTableModel.hasSQLEnv())) {
                                                oldTableStarColumn.setShowStar(false);
                                                relation.setShowStarRelation(false);
                                        }

                                        if ((newNameTableModel.isCreateTable() || newNameTableModel.hasSQLEnv())) {
                                                newTableStarColumn.setShowStar(false);
                                                relation.setShowStarRelation(false);
                                        }

                                }
                        }
                        else if (option.getOptionType() == EAlterTableOptionType.appendFrom) {
                                TObjectName newTableName = option.getSourceTableName();
                                Stack<TParseTreeNode> list = newTableName.getStartToken().getNodesStartFromThisToken();
                                boolean containsTable = false;
                                for (int j = 0; j < list.size(); j++) {
                                        if (list.get(j) instanceof TTable) {
                                                TTable newTableTable = (TTable) list.get(j);
                                                Table newNameTableModel = modelFactory.createTable(newTableTable);
                                                newNameTableModel.setStarStmt("append_from");

                                                TObjectName newStarColumn = DlineageUtil.syntheticStarName();
                                                TableColumn newTableStarColumn = modelFactory.createTableColumn(newNameTableModel,
                                                                newStarColumn, true);

                                                Process process = modelFactory.createProcess(stmt);
                                                newNameTableModel.addProcess(process);
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.append_from);
                                                relation.setTarget(new TableColumnRelationshipElement(oldTableStarColumn));
                                                relation.addSource(new TableColumnRelationshipElement(newTableStarColumn));
                                                relation.setProcess(process);
                                                containsTable = true;

                                                if ((oldNameTableModel.isCreateTable() || oldNameTableModel.hasSQLEnv())) {
                                                        oldTableStarColumn.setShowStar(false);
                                                        relation.setShowStarRelation(false);
                                                }

                                                if ((newNameTableModel.isCreateTable() || newNameTableModel.hasSQLEnv())) {
                                                        newTableStarColumn.setShowStar(false);
                                                        relation.setShowStarRelation(false);
                                                }
                                        }
                                }
                                if (!containsTable) {
                                        Table newNameTableModel = modelFactory.createTableByName(newTableName);
                                        newNameTableModel.setStarStmt("append_from");
                                        TObjectName newStarColumn = DlineageUtil.syntheticStarName();
                                        TableColumn newTableStarColumn = modelFactory.createTableColumn(newNameTableModel, newStarColumn,
                                                        true);

                                        Process process = modelFactory.createProcess(stmt);
                                        newNameTableModel.addProcess(process);
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(EffectType.append_from);
                                        relation.setTarget(new TableColumnRelationshipElement(oldTableStarColumn));
                                        relation.addSource(new TableColumnRelationshipElement(newTableStarColumn));
                                        relation.setProcess(process);
                                        if ((oldNameTableModel.isCreateTable() || oldNameTableModel.hasSQLEnv())) {
                                                oldTableStarColumn.setShowStar(false);
                                                relation.setShowStarRelation(false);
                                        }

                                        if ((newNameTableModel.isCreateTable() || newNameTableModel.hasSQLEnv())) {
                                                newTableStarColumn.setShowStar(false);
                                                relation.setShowStarRelation(false);
                                        }

                                }
                        }
                        else if (option.getOptionType() == EAlterTableOptionType.exchangePartition) {
                                TObjectName newTableName = option.getNewTableName();
                                Stack<TParseTreeNode> list = newTableName.getStartToken().getNodesStartFromThisToken();
                                boolean containsTable = false;
                                for (int j = 0; j < list.size(); j++) {
                                        if (list.get(j) instanceof TTable) {
                                                TTable newTableTable = (TTable) list.get(j);
                                                Table newNameTableModel = modelFactory.createTable(newTableTable);
                                                newNameTableModel.setStarStmt("exchange_partition");

                                                TObjectName newStarColumn = DlineageUtil.syntheticStarName();
                                                TableColumn newTableStarColumn = modelFactory.createTableColumn(newNameTableModel,
                                                                newStarColumn, true);

                                                Process process = modelFactory.createProcess(stmt);
                                                newNameTableModel.addProcess(process);
                                                {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.exchange_partition);
                                                        relation.setTarget(new TableColumnRelationshipElement(oldTableStarColumn));
                                                        relation.addSource(new TableColumnRelationshipElement(newTableStarColumn));
                                                        relation.setProcess(process);
                                                        if (option.getPartitionName() != null) {
                                                                relation.setPartition(option.getPartitionName().toString());
                                                        }
                                                        if ((oldNameTableModel.isCreateTable() || oldNameTableModel.hasSQLEnv())) {
                                                                oldTableStarColumn.setShowStar(false);
                                                                relation.setShowStarRelation(false);
                                                        }

                                                        if ((newNameTableModel.isCreateTable() || newNameTableModel.hasSQLEnv())) {
                                                                newTableStarColumn.setShowStar(false);
                                                                relation.setShowStarRelation(false);
                                                        }
                                                }
                                                {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.exchange_partition);
                                                        relation.setTarget(new TableColumnRelationshipElement(newTableStarColumn));
                                                        relation.addSource(new TableColumnRelationshipElement(oldTableStarColumn));
                                                        relation.setProcess(process);
                                                        if (option.getPartitionName() != null) {
                                                                relation.setPartition(option.getPartitionName().toString());
                                                        }
                                                        if ((oldNameTableModel.isCreateTable() || oldNameTableModel.hasSQLEnv())) {
                                                                oldTableStarColumn.setShowStar(false);
                                                                relation.setShowStarRelation(false);
                                                        }

                                                        if ((newNameTableModel.isCreateTable() || newNameTableModel.hasSQLEnv())) {
                                                                newTableStarColumn.setShowStar(false);
                                                                relation.setShowStarRelation(false);
                                                        }
                                                }
                                                containsTable = true;   
                                        }
                                }
                                if (!containsTable) {
                                        Table newNameTableModel = modelFactory.createTableByName(newTableName);
                                        newNameTableModel.setStarStmt("exchange_partition");
                                        TObjectName newStarColumn = DlineageUtil.syntheticStarName();
                                        TableColumn newTableStarColumn = modelFactory.createTableColumn(newNameTableModel, newStarColumn,
                                                        true);

                                        Process process = modelFactory.createProcess(stmt);
                                        newNameTableModel.addProcess(process);
                                        {
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.exchange_partition);
                                                relation.setTarget(new TableColumnRelationshipElement(oldTableStarColumn));
                                                relation.addSource(new TableColumnRelationshipElement(newTableStarColumn));
                                                if (option.getPartitionName() != null) {
                                                        relation.setPartition(option.getPartitionName().toString());
                                                }
                                                relation.setProcess(process);
                                                if ((oldNameTableModel.isCreateTable() || oldNameTableModel.hasSQLEnv())) {
                                                        oldTableStarColumn.setShowStar(false);
                                                        relation.setShowStarRelation(false);
                                                }

                                                if ((newNameTableModel.isCreateTable() || newNameTableModel.hasSQLEnv())) {
                                                        newTableStarColumn.setShowStar(false);
                                                        relation.setShowStarRelation(false);
                                                }
                                        }
                                        {
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.exchange_partition);
                                                relation.setTarget(new TableColumnRelationshipElement(newTableStarColumn));
                                                relation.addSource(new TableColumnRelationshipElement(oldTableStarColumn));
                                                if (option.getPartitionName() != null) {
                                                        relation.setPartition(option.getPartitionName().toString());
                                                }
                                                relation.setProcess(process);
                                                if ((oldNameTableModel.isCreateTable() || oldNameTableModel.hasSQLEnv())) {
                                                        oldTableStarColumn.setShowStar(false);
                                                        relation.setShowStarRelation(false);
                                                }

                                                if ((newNameTableModel.isCreateTable() || newNameTableModel.hasSQLEnv())) {
                                                        newTableStarColumn.setShowStar(false);
                                                        relation.setShowStarRelation(false);
                                                }
                                        }
                                }
                        }
                        else if (option.getOptionType() == EAlterTableOptionType.switchPartition) {
                                analyzeSwitchPartition(stmt, option, oldNameTableModel, oldTableStarColumn);
                        }
                        else if(option.getOptionType() == EAlterTableOptionType.setLocation) {
                                TObjectName location = option.getTableLocation();
                                Process process = modelFactory.createProcess(stmt);
                                process.setType("Set Table Location");
                                oldNameTableModel.addProcess(process);
                                Table uriFile = modelFactory.createTableByName(location, true);
                                uriFile.setPath(true);
                                for (int j = 0; j < oldNameTableModel.getColumns().size(); j++) {
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        TObjectName fileUri = DlineageUtil.syntheticStarName();
                                        TableColumn fileUriColumn = modelFactory.createFileUri(uriFile, fileUri);
                                        relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                        relation.setTarget(new TableColumnRelationshipElement(oldNameTableModel.getColumns().get(j)));
                                        relation.setProcess(process);
                                }
                        }
                        else if (option.getOptionType() == EAlterTableOptionType.AddColumn
                                        || option.getOptionType() == EAlterTableOptionType.addColumnIfNotExists) {
                                if (option.getColumnDefinitionList() != null) {
                                        for (TColumnDefinition column : option.getColumnDefinitionList()) {
                                                if (column != null && column.getColumnName() != null) {
                                                        List<TableColumn> columnsBefore = new ArrayList<TableColumn>(oldNameTableModel.getColumns());
                                                        TableColumn tableColumn = modelFactory.createTableColumn(oldNameTableModel, column.getColumnName(), true);
                                                        if(this.option.getAnalyzeMode() == AnalyzeMode.crud) {
                                                                CrudRelationship crudRelationship = modelFactory.createCrudRelation();
                                                                crudRelationship.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                crudRelationship.setEffectType(EffectType.add_table_column);
                                                        }
                                                        // the added column's fields, as a CREATE TABLE declaring the column makes them; a column the
                                                        // table already had (ADD COLUMN IF NOT EXISTS) keeps its own (Mantis 4846)
                                                        if (tableColumn != null && nestedProfile().buildsDeclaredTree()
                                                                        && !containsSame(columnsBefore, tableColumn)) {
                                                                createStructFieldNodes(tableColumn, column.getDatatype(),
                                                                                new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>(),
                                                                                column.getColumnName(), new ArrayList<TableColumn>());
                                                        }
                                                }
                                        }
                                }
                        }
                        else if (option.getOptionType() == EAlterTableOptionType.DropColumn && this.option.getAnalyzeMode() == AnalyzeMode.crud) {
                                if (option.getColumnNameList() != null) {
                                        for (TObjectName column : option.getColumnNameList()) {
                                                TableColumn tableColumn = modelFactory.createTableColumn(oldNameTableModel, column, true);
                                                CrudRelationship crudRelationship = modelFactory.createCrudRelation();
                                                crudRelationship.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                crudRelationship.setEffectType(EffectType.drop_table_column);
                                        }
                                }
                        }
                        else if(option.getOptionType() == EAlterTableOptionType.AddConstraint || option.getOptionType() == EAlterTableOptionType.AddConstraintFK
                                        || option.getOptionType() == EAlterTableOptionType.AddConstraintPK || option.getOptionType() == EAlterTableOptionType.AddConstraintUnique
                                        || option.getOptionType() == EAlterTableOptionType.AddConstraintIndex){
                                if (option.getTableConstraint() != null) {
                                        TConstraint alertTableConstraint = option.getTableConstraint();
                                        TPTNodeList<TColumnWithSortOrder> keyNames = alertTableConstraint.getColumnList();
                                        if (keyNames == null) {
                                                continue;
                                        }
                                        for (int k = 0; k < keyNames.size(); k++) {
                                                TObjectName keyName = keyNames.getElement(k).getColumnName();
                                                TObjectName referencedTableName = alertTableConstraint.getReferencedObject();
                                                Table tableModel = modelFactory.createTableByName(stmt.getTableName());
                                                TableColumn tableConstraint = modelFactory.createTableColumn(tableModel, keyName, true);
                                                if(alertTableConstraint.getConstraint_type() == EConstraintType.primary_key){
                                                        tableConstraint.setPrimaryKey(true);
                                                }
                                                else if(alertTableConstraint.getConstraint_type() == EConstraintType.table_index){
                                                        tableConstraint.setIndexKey(true);
                                                }
                                                else if(alertTableConstraint.getConstraint_type() == EConstraintType.unique){
                                                        tableConstraint.setUnqiueKey(true);
                                                }
                                                else if (alertTableConstraint.getConstraint_type() == EConstraintType.foreign_key) {
                                                        tableConstraint.setForeignKey(true);
                                                        Table referencedTable = modelManager.getTableByName(DlineageUtil.getTableIdentityKey(referencedTableName.toString()));
                                                        if (referencedTable == null) {
                                                                referencedTable = modelFactory.createTableByName(referencedTableName);
                                                        }
                                                        TObjectNameList referencedTableColumns = alertTableConstraint.getReferencedColumnList();
                                                        if (k == keyNames.size() - 1) {
                                                                captureCompositeForeignKey(tableModel, keyNames, referencedTable,
                                                                                referencedTableColumns);
                                                        }
                                                        if (referencedTableColumns != null) {
                                                                for (int j = 0; j < referencedTableColumns.size(); j++) {
                                                                        TableColumn tableColumn = modelFactory.createTableColumn(referencedTable,
                                                                                        referencedTableColumns.getObjectName(j), false);
                                                                        if (tableColumn != null) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                                relation.setEffectType(EffectType.foreign_key);
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                                if(this.option.isShowERDiagram()){
                                                                                        ERRelationship erRelation = modelFactory.createERRelation();
                                                                                        erRelation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                        erRelation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                        else{
                                                                TableColumn tableColumn = modelFactory.createTableColumn(referencedTable, keyName, false);
                                                                if (tableColumn != null) {
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                        relation.setEffectType(EffectType.foreign_key);
                                                                        if(this.option.isShowERDiagram()){
                                                                                ERRelationship erRelation = modelFactory.createERRelation();
                                                                                erRelation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                erRelation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                                else if (option.getConstraintList() != null) {
                                        for(int iCons=0; iCons<option.getConstraintList().size(); iCons++){
                                                TConstraint alertTableConstraint = option.getConstraintList().getConstraint(iCons);
                                                TPTNodeList<TColumnWithSortOrder> keyNames = alertTableConstraint.getColumnList();
                                                if(keyNames != null){
                                                        for (int k = 0; k < keyNames.size(); k++) {
                                                                TObjectName keyName = keyNames.getElement(k).getColumnName();
                                                                TObjectName referencedTableName = alertTableConstraint.getReferencedObject();
                                                                Table tableModel = modelFactory.createTableByName(stmt.getTableName());
                                                                TableColumn tableConstraint = modelFactory.createTableColumn(tableModel, keyName, true);
                                                                if(alertTableConstraint.getConstraint_type() == EConstraintType.primary_key){
                                                                        tableConstraint.setPrimaryKey(true);
                                                                }
                                                                else if(alertTableConstraint.getConstraint_type() == EConstraintType.table_index){
                                                                        tableConstraint.setIndexKey(true);
                                                                }
                                                                else if(alertTableConstraint.getConstraint_type() == EConstraintType.unique){
                                                                        tableConstraint.setUnqiueKey(true);
                                                                }
                                                                else if (alertTableConstraint.getConstraint_type() == EConstraintType.foreign_key) {
                                                                        tableConstraint.setForeignKey(true);
                                                                        Table referencedTable = modelManager.getTableByName(DlineageUtil.getTableIdentityKey(referencedTableName.toString()));
                                                                        if (referencedTable == null) {
                                                                                referencedTable = modelFactory.createTableByName(referencedTableName);
                                                                        }
                                                                        TObjectNameList referencedTableColumns = alertTableConstraint.getReferencedColumnList();
                                                                        if (k == keyNames.size() - 1) {
                                                                                captureCompositeForeignKey(tableModel, keyNames, referencedTable,
                                                                                                referencedTableColumns);
                                                                        }
                                                                        if (referencedTableColumns != null) {
                                                                                for (int j = 0; j < referencedTableColumns.size(); j++) {
                                                                                        TableColumn tableColumn = modelFactory.createTableColumn(referencedTable,
                                                                                                        referencedTableColumns.getObjectName(j), false);
                                                                                        if (tableColumn != null) {
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                                                relation.setEffectType(EffectType.foreign_key);
                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                relation.setProcess(process);
                                                                                                if(this.option.isShowERDiagram()){
                                                                                                        ERRelationship erRelation = modelFactory.createERRelation();
                                                                                                        erRelation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                        erRelation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                        else{
                                                                                TableColumn tableColumn = modelFactory.createTableColumn(referencedTable, keyName, false);
                                                                                if (tableColumn != null) {
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                                        relation.setEffectType(EffectType.foreign_key);
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                        if(this.option.isShowERDiagram()){
                                                                                                ERRelationship erRelation = modelFactory.createERRelation();
                                                                                                erRelation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                erRelation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                                else if (option.getIndexCols() != null){
                                        TPTNodeList<TColumnWithSortOrder> keyNames = option.getIndexCols();
                                        for (int k = 0; k < keyNames.size(); k++) {
                                                TObjectName keyName = keyNames.getElement(k).getColumnName();
                                                Table tableModel = modelFactory.createTableByName(stmt.getTableName());
                                                TableColumn tableConstraint = modelFactory.createTableColumn(tableModel, keyName, true);
                                                if(option.getOptionType() == EAlterTableOptionType.AddConstraintPK){
                                                        tableConstraint.setPrimaryKey(true);
                                                }
                                                else if(option.getOptionType() == EAlterTableOptionType.AddConstraintIndex){
                                                        tableConstraint.setIndexKey(true);
                                                }
                                                else if(option.getOptionType() == EAlterTableOptionType.AddConstraintUnique){
                                                        tableConstraint.setUnqiueKey(true);
                                                }
                                                else if (option.getOptionType() == EAlterTableOptionType.AddConstraintFK) {
                                                        TObjectName referencedTableName = option.getReferencedObjectName();
                                                        tableConstraint.setForeignKey(true);
                                                        Table referencedTable = modelManager.getTableByName(DlineageUtil.getTableIdentityKey(referencedTableName.toString()));
                                                        if (referencedTable == null) {
                                                                referencedTable = modelFactory.createTableByName(referencedTableName);
                                                        }
                                                        TObjectNameList referencedTableColumns = option.getReferencedColumnList();
                                                        if (k == keyNames.size() - 1) {
                                                                captureCompositeForeignKey(tableModel, keyNames, referencedTable,
                                                                                referencedTableColumns);
                                                        }
                                                        if (referencedTableColumns != null) {
                                                                for (int j = 0; j < referencedTableColumns.size(); j++) {
                                                                        TableColumn tableColumn = modelFactory.createTableColumn(referencedTable,
                                                                                        referencedTableColumns.getObjectName(j), false);
                                                                        if (tableColumn != null) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                                relation.setEffectType(EffectType.foreign_key);
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                                if(this.option.isShowERDiagram()){
                                                                                        ERRelationship erRelation = modelFactory.createERRelation();
                                                                                        erRelation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                        erRelation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                        else{
                                                                TableColumn tableColumn = modelFactory.createTableColumn(referencedTable, keyName, false);
                                                                if (tableColumn != null) {
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                        relation.setEffectType(EffectType.foreign_key);
                                                                        Process process = modelFactory.createProcess(stmt);
                                                                        relation.setProcess(process);
                                                                        if(this.option.isShowERDiagram()){
                                                                                ERRelationship erRelation = modelFactory.createERRelation();
                                                                                erRelation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                erRelation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        private void analyzeAlterViewStmt(TAlterViewStatement stmt) {
                if (stmt.getAlterViewOption() == EAlterViewOption.asSelect) {
                        analyzeCreateViewStmt(stmt, stmt.getSelectSqlStatement(), null, stmt.getViewName());
                } else {
                        throw new UnsupportedOperationException("Can't handle this alter view statement case, alter option = "+ stmt.getAlterViewOption().name());
                }
        }
        
        private void analyzeDeleteStmt(TDeleteSqlStatement stmt) {
                TTable targetTable = stmt.getTargetTable();
                if (targetTable == null)
                        return;

                TTable table = targetTable;
                Table tableModel = null;
                TSelectSqlStatement projectedSubquery = null;
                TObjectNameList exposedColumns = null;
                if (targetTable.getCTE() != null) {
                        projectedSubquery = targetTable.getCTE().getSubquery();
                        exposedColumns = targetTable.getCTE().getColumnList();
                } else if (targetTable.getLinkTable() != null
                                && targetTable.getLinkTable().getSubquery() != null) {
                        projectedSubquery = targetTable.getLinkTable().getSubquery();
                        exposedColumns = getProjectedTargetColumns(targetTable.getLinkTable());
                } else if (targetTable.getSubquery() != null) {
                        projectedSubquery = targetTable.getSubquery();
                        exposedColumns = getProjectedTargetColumns(targetTable);
                }

                if (projectedSubquery != null) {
                        CteWriteTargetResolution resolution = resolveCteDeleteTarget(projectedSubquery);
                        if (resolution.isWritable()) {
                                analyzeProjectedWriteTarget(targetTable, projectedSubquery, exposedColumns, null);
                                table = resolution.baseTable;
                                tableModel = modelFactory.createTable(table);
                                createProjectedWriteImpact(projectedSubquery, tableModel, EffectType.delete, null);
                        } else {
                                analyzeProjectedWriteTarget(targetTable, projectedSubquery, exposedColumns, null);
                                addCteWriteTargetHint(targetTable, resolution.failureReason);
                        }
                } else {
                        tableModel = modelFactory.createTable(table);
                }
                if (tableModel != null && getTableLinkedColumns(table) != null
                                && getTableLinkedColumns(table).size() > 0) {
                        for (int j = 0; j < getTableLinkedColumns(table).size(); j++) {
                                TObjectName object = getTableLinkedColumns(table).getObjectName(j);

                                if (object.getDbObjectType() == EDbObjectType.variable) {
                                        continue;
                                }

                                if (object.getColumnNameOnly().startsWith("@")
                                                && (option.getVendor() == EDbVendor.dbvmssql || option.getVendor() == EDbVendor.dbvazuresql)) {
                                        continue;
                                }

                                if (object.getColumnNameOnly().startsWith(":")
                                                && (option.getVendor() == EDbVendor.dbvhana || option.getVendor() == EDbVendor.dbvteradata)) {
                                        continue;
                                }

                                if (!isBuiltInFunctionName(object)) {
                                        if (object.getSourceTable() == null || object.getSourceTable() == table) {
                                                modelFactory.createTableColumn(tableModel, object, false);
                                        }
                                }
                        }
                }

                if(option.getAnalyzeMode() == AnalyzeMode.crud && tableModel != null) {
                        CrudRelationship crudRelationship = modelFactory.createCrudRelation();
                        crudRelationship.setTarget(new TableRelationshipElement(tableModel));
                        crudRelationship.setEffectType(EffectType.delete);
                }
                
                if (stmt.getWhereClause() != null && stmt.getWhereClause().getCondition() != null) {
                        analyzeFilterCondition(tableModel, stmt.getWhereClause().getCondition(), null, JoinClauseType.where,
                                        EffectType.delete);
                }
        }

        private TObjectName getProcedureName(TStoredProcedureSqlStatement stmt) {
                if (stmt instanceof TTeradataCreateProcedure) {
                        return ((TTeradataCreateProcedure) stmt).getProcedureName();
                }
                return DlineageUtil.getProcedureOrFunctionName(stmt);
        }

        private void analyzePlsqlCreatePackage(TPlsqlCreatePackage stmt) {
                TObjectName procedureName = getProcedureName(stmt);
                OraclePackage oraclePackage;
                if (procedureName != null) {
                        RoutineAliasKey[] packageKeys = ModelFactory.packageAliasKeys(stmt);
                        RoutineAliasKey packageKey = packageKeys == null ? null : packageKeys[0];
                        if (this.modelManager.getOraclePackage(packageKey) == null) {
                                oraclePackage = this.modelFactory.createOraclePackage(stmt);

                                if (stmt.getParameterDeclarations() != null) {
                                        TParameterDeclarationList parameters = stmt.getParameterDeclarations();

                                        for (int i = 0; i < parameters.size(); ++i) {
                                                TParameterDeclaration parameter = parameters.getParameterDeclarationItem(i);
                                                if (parameter.getParameterName() != null) {
                                                        this.modelFactory.createProcedureArgument(oraclePackage, parameter, i + 1);
                                                } else if (parameter.getDataType() != null) {
                                                        this.modelFactory.createProcedureArgument(oraclePackage, parameter, i + 1);
                                                }
                                        }
                                }

                                ModelBindingManager.setGlobalOraclePackage(oraclePackage);
                        } else {
                                ModelBindingManager.setGlobalOraclePackage(this.modelManager.getOraclePackage(packageKey));
                        }
                        
                        try {
                                if (stmt.getDeclareStatements() != null) {
                                        // Register member identities before analyzing bodies: an orchestrator often
                                        // precedes its callees. This does not visit or execute any member body.
                                        if (option.getVendor() == EDbVendor.dbvoracle) {
                                                for (int i = 0; i < stmt.getDeclareStatements().size(); ++i) {
                                                        TCustomSqlStatement member = stmt.getDeclareStatements().get(i);
                                                        if (member instanceof TStoredProcedureSqlStatement) {
                                                                TObjectName memberName = getProcedureName((TStoredProcedureSqlStatement) member);
                                                                if (memberName != null && member.sqlstatementtype.name().contains("procedure")
                                                                                && DlineageUtil.isProcedureExcluded(memberName.toString())) continue;
                                                                Procedure model = modelFactory.createProcedure((TStoredProcedureSqlStatement) member);
                                                                if (model != null) model.setParentPackage(ModelBindingManager.getGlobalOraclePackage());
                                                        }
                                                }
                                        }
                                        for (int i = 0; i < stmt.getDeclareStatements().size(); ++i) {
                                                analyzeCustomSqlStmt(stmt.getDeclareStatements().get(i));
                                        }
                                }
                                List<Pair<TBasicStmt, Procedure>> pending = pendingOracleCallArguments.remove(
                                                ModelBindingManager.getGlobalOraclePackage());
                                if (pending != null) {
                                        for (Pair<TBasicStmt, Procedure> item : pending) {
                                                TStoredProcedureSqlStatement saved = ModelBindingManager.getGlobalProcedure();
                                                stmtStack.push(item.first);
                                                try {
                                                        ModelBindingManager.setGlobalProcedure(oracleRoutineParent(item.first));
                                                        analyzeOracleCallArguments(item.second, item.first.getExpr().getFunctionCall());
                                                } finally {
                                                        stmtStack.pop();
                                                        ModelBindingManager.setGlobalProcedure(saved);
                                                }
                                        }
                                }
                        } finally {
                                pendingOracleCallArguments.remove(ModelBindingManager.getGlobalOraclePackage());
                                ModelBindingManager.removeGlobalOraclePackage();
                        }
                }
        }

        /**
         * B1 (routine-summary-scc-design §2.1a): canonical signature descriptor of
         * a routine DECLARATION, built once at declaration time. Null when the
         * statement carries no resolvable name.
         */
        private gudusoft.gsqlparser.dlineage.dynamicsql.RoutineIdentity declarationIdentityOf(
                        TStoredProcedureSqlStatement stmt) {
                TObjectName name = getProcedureName(stmt);
                if (name == null || name.getObjectString() == null
                                || name.getObjectString().length() == 0) {
                        return null;
                }
                boolean isFunction = stmt instanceof gudusoft.gsqlparser.stmt.TCreateFunctionStmt
                                || stmt instanceof gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateFunction;
                boolean isTrigger = stmt instanceof TCreateTriggerStmt
                                || stmt instanceof TPlsqlCreateTrigger;
                String packageName = null;
                gudusoft.gsqlparser.dlineage.dynamicsql.RoutineKind kind;
                if (isTrigger) {
                        kind = gudusoft.gsqlparser.dlineage.dynamicsql.RoutineKind.TRIGGER;
                } else if (ModelBindingManager.getGlobalOraclePackage() != null) {
                        packageName = ModelBindingManager.getGlobalOraclePackage().getName();
                        kind = isFunction
                                        ? gudusoft.gsqlparser.dlineage.dynamicsql.RoutineKind.PACKAGE_MEMBER_FUNCTION
                                        : gudusoft.gsqlparser.dlineage.dynamicsql.RoutineKind.PACKAGE_MEMBER_PROCEDURE;
                } else {
                        kind = isFunction
                                        ? gudusoft.gsqlparser.dlineage.dynamicsql.RoutineKind.FUNCTION
                                        : gudusoft.gsqlparser.dlineage.dynamicsql.RoutineKind.PROCEDURE;
                }
                // mssql numbered procedures: the parser drops ";N" from the AST name;
                // recover it from the token stream so grp;1 / grp;2 keep DISTINCT
                // identity scope keys (per-overload pools — codex-B3-r2 finding 6).
                String overloadDiscriminator = option.getVendor() == EDbVendor.dbvmssql
                                ? gudusoft.gsqlparser.dlineage.dynamicsql.RoutineCatalog
                                                .numberedGroupAfter(name)
                                : null;
                return gudusoft.gsqlparser.dlineage.dynamicsql.RoutineIdentity.of(
                                option.getVendor(), kind, name.getDatabaseString(),
                                name.getSchemaString(), packageName, name.getObjectString(),
                                stmt.getParameterDeclarations(), overloadDiscriminator);
        }

        private void analyzeStoredProcedureStmt(TStoredProcedureSqlStatement stmt) {

                if (stmt instanceof TPlsqlCreatePackage) {
                        analyzePlsqlCreatePackage((TPlsqlCreatePackage) stmt);
                        return;
                }
                
                // An anonymous block inside a routine runs as part of that routine: its temporary tables are
                // the routine's, and the routine is still the one being analyzed when the block ends.
                TStoredProcedureSqlStatement enclosingRoutine = ModelBindingManager.getGlobalProcedure();
                boolean innerBlock = enclosingRoutine != null && stmt.getStoredProcedureName() == null;
                ModelBindingManager.setGlobalProcedure(stmt);
                List<Map> temporaryBindings = !innerBlock && TemporaryTableSemantics.hasTransientTables(stmt.dbvendor)
                                ? modelManager.enterTemporaryTableScope() : null;

                boolean pushedIdentityScope = false;
                try {
                        Procedure procedure = null;

                        TObjectName procedureName = getProcedureName(stmt);

                        // Honor procedure-exclusion patterns/names for procedures defined in actual SQL
                        // (CREATE PROCEDURE). Previously exclusion was only applied to procedures loaded
                        // from metadata JSON; a CREATE PROCEDURE parsed from SQL still produced its
                        // procedure node plus all of its inner-statement processes and relationships
                        // regardless of the exclusion configuration (MantisBT 4533).
                        //
                        // analyzeStoredProcedureStmt also handles functions and triggers (every dialect's
                        // CREATE FUNCTION / CREATE TRIGGER class extends TStoredProcedureSqlStatement), which
                        // are NOT procedures and must never be dropped by procedure exclusion. Gate on the
                        // statement type rather than enumerating classes: across all dialects the procedure
                        // statement types are exactly those whose ESqlStatementType name contains "procedure"
                        // (e.g. sstcreateprocedure, sstoraclecreateprocedure, sstmssqlcreateprocedure),
                        // while function/trigger types contain "function"/"trigger".
                        boolean isProcedureStmt = stmt.sqlstatementtype != null
                                        && stmt.sqlstatementtype.name().toLowerCase(Locale.ROOT).contains("procedure");
                        if (procedureName != null && isProcedureStmt
                                        && DlineageUtil.isProcedureExcluded(procedureName.toString())) {
                                return;
                        }

                        if (procedureName != null) {
                                procedure = this.modelFactory.createProcedure(stmt);
                                if (procedure != null) {
                                        modelManager.bindModel(stmt, procedure);
                                }
                                if (ModelBindingManager.getGlobalOraclePackage() != null) {
                                        ModelBindingManager.getGlobalOraclePackage().addProcedure(procedure);
                                        procedure.setParentPackage(ModelBindingManager.getGlobalOraclePackage());
                                        // Canonical scope key of this member's variables: the same
                                        // value createVariable(String) keys them under while the
                                        // body is analyzed (fullName/name are display forms and
                                        // must not be touched).
                                        procedure.setVariableScopeKey(DlineageUtil.getProcedureParentName(stmt));
                                } else if (procedure != null) {
                                        // A label of the routine's variable scope, its name as written (variables are keyed by
                                        // LocalSymbolKey; the label only names the scope, as for package members above).
                                        procedure.setVariableScopeKey(DlineageUtil.getProcedureParentName(stmt));
                                }
                                if (procedure != null) {
                                        // B1 (routine-summary-scc-design §3): additive identity
                                        // metadata. The identityScopeKey discriminates same-named
                                        // overloads; LEGACY paths never consult it (B3's
                                        // identity-first lookup is the consumer).
                                        gudusoft.gsqlparser.dlineage.dynamicsql.RoutineIdentity routineIdentity =
                                                        declarationIdentityOf(stmt);
                                        procedure.setRoutineIdentity(routineIdentity);
                                        if (procedure.getVariableScopeKey() != null && routineIdentity != null) {
                                                procedure.setIdentityScopeKey(DlineageUtil.identityScopeKey(
                                                                procedure.getVariableScopeKey(), routineIdentity));
                                        }
                                        // B3 (routine-summary-scc-design §3): object-level
                                        // per-overload variable pools, keyed by the routine's frozen
                                        // scope and declaration identity. Mode-gated — LEGACY never
                                        // pushes, so the identity pool path stays cold there.
                                        if (option.isIdentityFirstVariablePools() && routineIdentity != null) {
                                                modelFactory.pushIdentityScope(procedure.getIdentityScopeKey(), procedure);
                                                pushedIdentityScope = true;
                                        }
                                }
                                if (stmt.getParameterDeclarations() != null) {
                                        TParameterDeclarationList parameters = stmt.getParameterDeclarations();
        
                                        for (int i = 0; i < parameters.size(); ++i) {
                                                TParameterDeclaration parameter = parameters.getParameterDeclarationItem(i);
                                                Argument argument = null;
                                                TObjectName argumentName = null;
                                                if (parameter.getParameterName() != null) {
                                                        argument = this.modelFactory.createProcedureArgument(procedure, parameter, i + 1);
                                                        argumentName = parameter.getParameterName();
                                                } else if (parameter.getDataType() != null) {
                                                        argument = this.modelFactory.createProcedureArgument(procedure, parameter, i + 1);
                                                }
                                                
                                                if (argument != null) {
                                                        if (argumentName == null) {
                                                                argumentName = new TObjectName();
                                                                argumentName.setString(argument.getName());
                                                        }
                                                        Variable variable = modelFactory.createVariable(argument.getName());
                                                        // B1: index the formal under the overload-
                                                        // discriminating identity scope too (lookup-map
                                                        // only; consumed by B3's identity-first path).
                                                        modelFactory.bindVariableUnderIdentityScope(
                                                                        procedure, argument.getName(), variable);
                                                        if (argument.getMode() == EParameterMode.in || argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                                                variable.setSubType(SubType.of(argument.getMode().name()));
                                                        } else {
                                                                variable.setSubType(SubType.argument);
                                                        }
                                                        TableColumn parameterField;
                                                        if(isSimpleDataType(argument.getDataType())){
                                                                parameterField = modelFactory.createTableColumn(variable, argumentName, true);
                                                        }
                                                        else {
                                                                TObjectName variableProperties = DlineageUtil.syntheticStarName();
                                                                parameterField = modelFactory.createTableColumn(variable, variableProperties, true);
                                                        }
                                                        if (shouldCollectAuthoritativeLineageEvidence()) {
                                                                authoritativeEvidenceCollector.bindRoutineParameter(argument, parameterField);
                                                        }
                                                }
                                        }
                                }
                        }
        
                        if (stmt instanceof TCreateTriggerStmt) {
                                TCreateTriggerStmt trigger = (TCreateTriggerStmt) stmt;
        
                                if (trigger.getFunctionCall() != null) {
                                        modelFactory.createProcedureFromFunctionCall(trigger.getFunctionCall());
                                }
        
                                if (trigger.getTables() != null) {
                                        for (int i = 0; i < trigger.getTables().size(); i++) {
                                                Table tableModel = this.modelFactory.createTriggerOnTable(trigger.getTables().getTable(i));
                                        }
                                }
                        }
        
                        if (stmt instanceof TPlsqlCreateTrigger && ((TPlsqlCreateTrigger) stmt).getTriggeringClause()!=null
                                        && ((TPlsqlCreateTrigger) stmt).getTriggeringClause().getEventClause() instanceof TDmlEventClause) {
                                TPlsqlCreateTrigger trigger = (TPlsqlCreateTrigger) stmt;
                                TDmlEventClause clause = (TDmlEventClause) ((TPlsqlCreateTrigger) stmt).getTriggeringClause()
                                                .getEventClause();
                                Table sourceTable = modelFactory.createTableByName(clause.getTableName());

                                bindTriggerCorrelationNames(trigger, sourceTable);
        
                                for (TTriggerEventItem item : clause.getEventItems()) {
                                        if (item instanceof TDmlEventItem) {
                                                if (((TDmlEventItem) item).getColumnList() != null) {
                                                        for (TObjectName column : ((TDmlEventItem) item).getColumnList()) {
                                                                modelFactory.createTableColumn(sourceTable, column, true);
                                                        }
                                                }
                                        }
                                }
        
                                for (TCustomSqlStatement subStmt : ((TPlsqlCreateTrigger) stmt).getStatements()) {
                                        if (!(subStmt instanceof TCommonBlock))
                                                continue;
                                        for (TCustomSqlStatement blockSubStmt : ((TCommonBlock) subStmt).getStatements()) {
                                                if (!(blockSubStmt instanceof TBasicStmt))
                                                        continue;
                                                TBasicStmt basicStmt = (TBasicStmt) blockSubStmt;
                                                TExpression expression = basicStmt.getExpr();
                                                if (expression != null && expression.getExpressionType() == EExpressionType.function_t) {
                                                        Procedure targetProcedure = modelManager.getProcedure(tableDefaultedAliasKey(nameAliasKey(expression.getFunctionCall().getFunctionName(), null)));
                                                        if (targetProcedure == null) {
                                                                targetProcedure = modelManager.getProcedure(procedure.getSchema() == null ? null : tableDefaultedAliasKey(qualifiedAliasKey(
                                                                                                                nameAliasKey(expression.getFunctionCall().getFunctionName(), null), procedure.getSchema())));
                                                        }
                                                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("triggerArguments", expression.getFunctionCall().getFunctionName(), targetProcedure,
                                                                        new Integer[] {null}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.ROUTINE);
                                                        if (targetProcedure != null && expression.getFunctionCall().getArgs() != null && expression
                                                                        .getFunctionCall().getArgs().size() == targetProcedure.getArguments().size()) {
                                                                for (int j = 0; j < expression.getFunctionCall().getArgs().size(); j++) {
                                                                        TExpression columnExpr = expression.getFunctionCall().getArgs().getExpression(j);
                                                                        if (columnExpr.getExpressionType() == EExpressionType.simple_object_name_t) {
                                                                                TObjectName columnObject = columnExpr.getObjectOperand();
                                                                                if (columnObject.toString().indexOf(":") != -1) {
                                                                                        TableColumn tableColumn = modelFactory.createTableColumn(sourceTable,
                                                                                                        columnObject, true);
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.trigger);
                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.setTarget(
                                                                                                        new ArgumentRelationshipElement(targetProcedure.getArguments().get(j)));
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
        
                        if (stmt instanceof TMssqlCreateFunction) {
                                TMssqlCreateFunction createFunction = (TMssqlCreateFunction) stmt;
                                if (createFunction.getReturnTableVaraible() != null && createFunction.getReturnTableDefinitions() != null) {
                                        Variable tableModel = this.modelFactory.createVariable(createFunction.getReturnTableVaraible());
                                        tableModel.setVariable(true);
                                        tableModel.setCreateTable(true);
                                        if (procedure != null) {
                                                tableModel.setProcedureId(String.valueOf(procedure.getId()));
                                                tableModel.setTarget(true);
                                        }
                                        String procedureParent = createFunction.getFunctionName().toString();
                                        if (procedureParent != null) {
                                                tableModel.setParent(procedureParent);
                                        }
                                        modelManager.bindFunctionResult(nameAliasKey(createFunction.getFunctionName(), null), tableModel);
        
                                        if (createFunction.getReturnTableDefinitions() != null) {
                                                for (int j = 0; j < createFunction.getReturnTableDefinitions().size(); j++) {
                                                        TTableElement tableElement = createFunction.getReturnTableDefinitions().getTableElement(j);
                                                        TColumnDefinition column = tableElement.getColumnDefinition();
                                                        if (column != null && column.getColumnName() != null) {
                                                                modelFactory.createTableColumn(tableModel, column.getColumnName(), true);
                                                        }
                                                }
                                        }
                                }
        
                                if (createFunction.getReturnStmt() != null && createFunction.getReturnStmt().getSubquery() != null) {
                                        String procedureParent = createFunction.getFunctionName().toString();
                                        analyzeSelectStmt(createFunction.getReturnStmt().getSubquery());
                                        ResultSet resultSetModel = (ResultSet) modelManager
                                                        .getModel(createFunction.getReturnStmt().getSubquery());
                                        if (procedure != null) {
                                                resultSetModel.setProcedureId(String.valueOf(procedure.getId()));
                                                resultSetModel.setTarget(true);
                                        }
                                        modelManager.bindFunctionResult(nameAliasKey(createFunction.getFunctionName(), null), resultSetModel);
                                }
                        } else if (stmt instanceof TCreateFunctionStmt) {
                                TCreateFunctionStmt createFunction = (TCreateFunctionStmt) stmt;
                                if (createFunction.getReturnDataType() != null
                                                && createFunction.getReturnDataType().getColumnDefList() != null) {
                                        Table tableModel = this.modelFactory.createTableByName(createFunction.getFunctionName(), true);
                                        tableModel.setCreateTable(true);
                                        String procedureParent = createFunction.getFunctionName().toString();
                                        if (procedureParent != null) {
                                                tableModel.setParent(procedureParent);
                                        }
        
                                        modelManager.bindFunctionResult(nameAliasKey(createFunction.getFunctionName(), null), tableModel);
                                        for (int j = 0; j < createFunction.getReturnDataType().getColumnDefList().size(); j++) {
                                                TColumnDefinition column = createFunction.getReturnDataType().getColumnDefList().getColumn(j);
                                                if (column != null && column.getColumnName() != null) {
                                                        modelFactory.createTableColumn(tableModel, column.getColumnName(), true);
                                                }
                                        }
        
                                        if (createFunction.getSqlQuery() != null) {
                                                analyzeSelectStmt(createFunction.getSqlQuery());
                                                ResultSet resultSetModel = (ResultSet) modelManager.getModel(createFunction.getSqlQuery());
                                                if (resultSetModel != null) {
                                                        for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                                                ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                                                for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                                        TableColumn tableColumn = tableModel.getColumns().get(j);
                                                                        if (sameModelColumn(resultColumn, tableColumn)) {
                                                                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                                                dataflowRelation.setEffectType(EffectType.select);
                                                                                dataflowRelation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                dataflowRelation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                                
                                if (createFunction.getReturnStmt() != null && createFunction.getReturnStmt().getSubquery() != null) {
                                        String procedureParent = createFunction.getFunctionName().toString();
                                        analyzeSelectStmt(createFunction.getReturnStmt().getSubquery());
                                        ResultSet resultSetModel = (ResultSet) modelManager
                                                        .getModel(createFunction.getReturnStmt().getSubquery());
                                        if (procedure != null) {
                                                resultSetModel.setProcedureId(String.valueOf(procedure.getId()));
                                                resultSetModel.setTarget(true);
                                        }
                                        modelManager.bindFunctionResult(nameAliasKey(createFunction.getFunctionName(), null), resultSetModel);
                                }
                                
                                if (createFunction.getReturnStmt() != null && createFunction.getReturnStmt().getReturnExpr() != null) {
                                        TExpression returnExpression =  createFunction.getReturnStmt().getReturnExpr();
                                        ResultSet returnResult = modelFactory.createResultSet(createFunction.getReturnStmt(), false);
                                        ResultColumn resultColumn = modelFactory.createResultColumn(returnResult, returnExpression);
                                        if (shouldCollectAuthoritativeLineageEvidence()) {
                                                authoritativeEvidenceCollector.bindRoutineReturn(procedure, resultColumn);
                                        }
                                        
                                        TExpression expression = createFunction.getReturnStmt().getReturnExpr();
                                        analyzeResultColumnExpressionRelation(resultColumn, expression);
        
                                        if (procedure != null) {
                                                returnResult.setProcedureId(String.valueOf(procedure.getId()));
                                                returnResult.setTarget(true);
                                        }
                                        String procedureParent = createFunction.getFunctionName().toString();
                                        modelManager.bindFunctionResult(nameAliasKey(createFunction.getFunctionName(), null), returnResult);
                                }
                        }
        
                        if (stmt instanceof TCreateProcedureStmt) {
                                TCreateProcedureStmt createProcedure = (TCreateProcedureStmt) stmt;
                                if (EDbVendor.dbvsnowflake == option.getVendor() && createProcedure.getRoutineBodyInConstant() != null) {
                                        String language = createProcedure.getProcedureLanguage() == null ? null
                                                        : createProcedure.getProcedureLanguage().toString();
                                        // Only a JAVASCRIPT body can be executed by the script-based
                                        // SQL extractor. Other handler languages (PYTHON, JAVA, SCALA)
                                        // are opaque to SQL analysis: keep the procedure model with its
                                        // declared language and skip the body (Mantis 4590).
                                        if (language == null || language.equalsIgnoreCase("JAVASCRIPT")) { // non-identifier-compare: LANGUAGE keyword, not a db object name
                                                extractSnowflakeSQLFromProcedure(createProcedure);
                                        }
                                }
                        }
                                
                        if (stmt.getStatements().size() > 0) {
                                for (int i = 0; i < stmt.getStatements().size(); ++i) {
                                        this.analyzeCustomSqlStmt(stmt.getStatements().get(i));
                                }
                        }

                        if (stmt.getBodyStatements().size() > 0) {
                                for (int i = 0; i < stmt.getBodyStatements().size(); ++i) {
                                        this.analyzeCustomSqlStmt(stmt.getBodyStatements().get(i));
                                }
                        }
                        
                        // Detect pipelined functions and build signatures
                        if (stmt instanceof TPlsqlCreateFunction && pipelinedAnalyzer != null) {
                                try {
                                        pipelinedAnalyzer.analyzePipelinedFunction((TPlsqlCreateFunction) stmt);
                                } catch (Exception e) {
                                        // Don't let pipelined analysis failure break main flow
                                }
                        }

                        if (procedure != null && !getLastSelectStmt(stmt).isEmpty()) {
                                for (TSelectSqlStatement select : getLastSelectStmt(stmt)) {
                                        ResultSet resultSet = (ResultSet) modelManager.getModel(select);
                                        resultSet.setProcedureId(String.valueOf(procedure.getId()));
                                        resultSet.setTarget(true);
                                        modelManager.bindFunctionResult(procedure.getAliasKey(), resultSet);
                                }
//                              List<Argument> outArgs = new ArrayList<Argument>();
//                              for (int i = 0; i < procedure.getArguments().size(); i++) {
//                                      Argument argument = procedure.getArguments().get(i);
//                                      if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
//                                              outArgs.add(argument);
//                                      }
//                              }
//
//                              if (resultSet != null && resultSet.getColumns().size() == outArgs.size()) {
//                                      for (int i = 0; i < outArgs.size(); i++) {
//                                              Argument argument = outArgs.get(i);
//                                              Variable variable = modelFactory.createVariable(argument.getName(), false);
//                                              if (variable != null) {
//                                                      DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
//                                                      dataflowRelation.setEffectType(EffectType.output);
//                                                      dataflowRelation
//                                                                      .addSource(new ResultColumnRelationshipElement(resultSet.getColumns().get(i)));
//                                                      dataflowRelation
//                                                                      .setTarget(new TableColumnRelationshipElement(variable.getColumns().get(0)));
//                                              }
//                                      }
//
//                              }
                        }

                        if (stmt instanceof TCreateFunctionStmt && ((TCreateFunctionStmt)stmt).getSqlExpression()!=null) {
                                TCreateFunctionStmt createFunction = (TCreateFunctionStmt) stmt;
                                TExpression returnExpression = createFunction.getSqlExpression();

                                ResultSet returnResult = modelFactory.createResultSet(stmt, false);
                                ResultColumn resultColumn = modelFactory.createResultColumn(returnResult, returnExpression);
                                if (shouldCollectAuthoritativeLineageEvidence()) {
                                        authoritativeEvidenceCollector.bindRoutineReturn(procedure, resultColumn);
                                }

                                columnsInExpr visitor = new columnsInExpr();
                                returnExpression.inOrderTraverse(visitor);

                                List<TObjectName> objectNames = visitor.getObjectNames();
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                List<TParseTreeNode> constants = visitor.getConstants();
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                                }
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.select);
                                }
                                if (objectNames != null && !objectNames.isEmpty()) {
                                        analyzeDataFlowRelation(resultColumn, objectNames, EffectType.select, functions);
                                }
                                if (constants != null && !constants.isEmpty()) {
                                        analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.select, functions);
                                }

                                String procedureParent = SQLUtil.trimColumnStringQuote(getProcedureParentName(stmt));
                                modelManager.bindFunctionResult(procedureParentAliasKey(stmt), returnResult);
                        }
                } finally {
                        if (pushedIdentityScope) {
                                modelFactory.popIdentityScope();
                        }
                        if (innerBlock) {
                                ModelBindingManager.setGlobalProcedure(enclosingRoutine);
                        } else {
                                ModelBindingManager.removeGlobalProcedure();
                        }
                        if (temporaryBindings != null) modelManager.leaveTemporaryTableScope(temporaryBindings);
                }

        }

        private boolean isSimpleDataType(TTypeName dataType) {
                if (dataType.getDataType() == EDataType.variant_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.cursor_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.generic_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.unknown_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.sql_variant_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.table_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.raw_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.resultset_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.row_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.map_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.anyType_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.struct_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.structType_t) {
                        return false;
                }
                if (dataType.getDataType() == EDataType.mapType_t) {
                        return false;
                }
                return true;
        }

        /**
         * ClickHouse remote()/remoteSecure() expose a real db.table on another
         * host as a table; modelling them as plain function nodes dropped the
         * upstream node and every edge into it. Returns true when the call was
         * modelled — the model is bound to the TTable, so the columns resolver2
         * already linked flow through the normal machinery. The model registers
         * through the ordinary table registry: a remote db.table shares identity
         * semantics with every other ClickHouse table reference.
         *
         * Only PROVABLE sources are modelled: plain object names or quoted
         * string constants, taken verbatim from the SQL text. Runtime
         * expressions and non-string constants (NULL, numbers) fall back to the
         * generic function node (never publish an unprovable edge).
         *
         * The PATH functions (file/s3/url/hdfs, their *Cluster variants and
         * azureBlobStorage) are deliberately NOT modelled: resource paths are
         * case-sensitive identities that do not fit the folded table-name
         * registry (bare filenames collide with same-spelling tables, case
         * variants coalesce, and Azure's first argument is a credential-bearing
         * connection string). Their missing upstream remains an HONEST, VISIBLE
         * gap — a generic function node — until a dedicated resource-identity
         * layer exists; see external_source_lineage_gap.md.
         *
         * Generator table functions (numbers(), generateRandom(), zeros(), ...)
         * correctly have NO upstream, which the generic node already expresses.
         */
        private boolean modelClickhouseExternalTableFunction(TTable table, TFunctionCall functionCall) {
                if (option.getVendor() != EDbVendor.dbvclickhouse) {
                        return false;
                }
                if (functionCall.getFunctionName() == null || functionCall.getArgs() == null
                                || functionCall.getArgs().size() < 2) {
                        return false;
                }
                String functionName = functionCall.getFunctionName().toString();
                if (!isClickhouseTableFunction(functionName, "remote")
                                && !isClickhouseTableFunction(functionName, "remoteSecure")) {
                        return false;
                }
                // remote(addresses, db, table[, user, password])
                // remote(addresses, db.table[, user, password])
                TExpressionList args = functionCall.getArgs();
                String first = literalTableFunctionArg(args.getExpression(1));
                if (first == null) {
                        return false;
                }
                String remoteTableName;
                if (first.indexOf('.') > 0) {
                        remoteTableName = first;
                } else {
                        String second = args.size() >= 3 ? literalTableFunctionArg(args.getExpression(2)) : null;
                        if (second == null) {
                                return false; // db without a provable table argument
                        }
                        remoteTableName = first + "." + second;
                }
                Table model = clickhouseExternalSourceModels.get(remoteTableName);
                if (model == null) {
                        model = modelFactory.createTableFromCreateDDL(table, false, remoteTableName);
                        clickhouseExternalSourceModels.put(remoteTableName, model);
                }
                modelManager.bindCreateModel(table, model);
                modelManager.bindModel(table, model);
                return true;
        }

        /** Same-literal remote() calls merge here; cleared in init(). */
        private final Map<String, Table> clickhouseExternalSourceModels = new LinkedHashMap<String, Table>();

        /**
         * ClickHouse function names are CASE-SENSITIVE (FiLe(...) is
         * UNKNOWN_FUNCTION natively) — matched through the canonical
         * per-object-type comparison, never a case fold.
         */
        private static boolean isClickhouseTableFunction(String rawName, String candidate) {
                return DlineageUtil.sameName(ESQLDataObjectType.dotFunction, rawName, candidate);
        }

        /** A provably literal identifier-ish argument: a plain object name or a
         *  QUOTED STRING constant (quotes stripped); null for anything computed —
         *  including non-string constants (NULL, numbers), which are not resource
         *  identities. */
        private static String literalTableFunctionArg(TExpression arg) {
                if (arg == null) {
                        return null;
                }
                if (arg.getObjectOperand() != null) {
                        return arg.getObjectOperand().toString();
                }
                return literalStringConstant(arg);
        }

        /** The DECODED value of a quoted string constant, or null. Delegates to
         *  the shared ClickHouse literal decoder (IdentifierCodec) — the raw
         *  spelling is not the value ('db\x2etable' IS db.table), the escape
         *  table must match ClickHouse's parseComplexEscapeSequence exactly, and
         *  a value that cannot be represented safely returns null so the caller
         *  falls back to the generic function node. */
        private static String literalStringConstant(TExpression arg) {
                if (arg == null || arg.getConstantOperand() == null) {
                        return null;
                }
                return gudusoft.gsqlparser.sqlenv.IdentifierCodec
                                .decodeClickHouseStringLiteral(arg.getConstantOperand().toString());
        }

        protected void analyzeResultColumnExpressionRelation(Object resultColumn, TExpression expression) {
                // SQL-LR: a nested analysis never inherits the reference of the loop that called it
                SqllrObservations sqllr = modelManager.getSqllrObservations();
                int sqllrBarrier = sqllr == null ? -1 : sqllr.openFrame();
                try {
                        analyzeResultColumnExpressionRelationInSqllrBarrier(resultColumn, expression);
                } finally {
                        if (sqllr != null) {
                                sqllr.closeFrame(sqllrBarrier);
                        }
                }
        }

        private void analyzeResultColumnExpressionRelationInSqllrBarrier(Object resultColumn, TExpression expression) {
                columnsInExpr visitor = new columnsInExpr();
                expression.inOrderTraverse(visitor);
                List<TObjectName> objectNames = visitor.getObjectNames();
                List<TParseTreeNode> functions = visitor.getFunctions();
                List<TParseTreeNode> constants = visitor.getConstants();
                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                if (functions != null && !functions.isEmpty()) {
                        analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                }
                if (subquerys != null && !subquerys.isEmpty()) {
                        analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.select);
                }
                if (objectNames != null && !objectNames.isEmpty()) {
                        analyzeDataFlowRelation(resultColumn, objectNames, EffectType.select, functions);
                }
                if (constants != null && !constants.isEmpty()) {
                        analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.select, functions);
                }
        }

        private void analyzeDb2ReturnStmt(TDb2ReturnStmt stmt) {
                if (stmt.getReturnExpr() != null) {
                        TExpression returnExpression = stmt.getReturnExpr();
                        ResultSet returnResult = modelFactory.createResultSet(stmt, true);
                        ResultColumn resultColumn = modelFactory.createResultColumn(returnResult, returnExpression);
                        bindCurrentRoutineReturn(resultColumn);
                        
                        columnsInExpr visitor = new columnsInExpr();
                        stmt.getReturnExpr().inOrderTraverse(visitor);
                        
                        List<TObjectName> objectNames = visitor.getObjectNames();
                        List<TParseTreeNode> functions = visitor.getFunctions();
                        List<TParseTreeNode> constants = visitor.getConstants();
                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                        if (functions != null && !functions.isEmpty()) {
                                analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                        }
                        if (subquerys != null && !subquerys.isEmpty()) {
                                analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.select);
                        }
                        if (objectNames != null && !objectNames.isEmpty()) {
                                analyzeDataFlowRelation(resultColumn, objectNames, EffectType.select, functions);
                        }
                        if (constants != null && !constants.isEmpty()) {
                                analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.select, functions);
                        }

                        String procedureParent = SQLUtil.trimColumnStringQuote(getProcedureParentName(stmt));
                        if (procedureParent != null) {
                                modelManager.bindFunctionResult(procedureParentAliasKey(stmt), returnResult);
                        }
                }
        }

        /**
         * PL/pgSQL {@code RETURN QUERY EXECUTE '<text>'} (plan 09 slice 13g): a command text the input writes as literals
         * (string constants, joined with ||) is a query whose rows the function returns. It is analysed as dynamic SQL of
         * this site and its result bound as the function's result; a text with any other part is not known before it runs
         * and keeps the old handling. False when this is no such statement.
         */
        private boolean analyzeReturnQueryExecute(TReturnStmt stmt) {
                EDbVendor vendor = stmt.dbvendor;
                if ((vendor != EDbVendor.dbvpostgresql && vendor != EDbVendor.dbvgreenplum && vendor != EDbVendor.dbvgaussdb)
                                || stmt.getExpression() == null || stmt.getStartToken() == null) {
                        return false;
                }
                TSourceToken query = stmt.getStartToken().nextSolidToken();
                TSourceToken execute = query == null ? null : query.nextSolidToken();
                if (query == null || execute == null || !"QUERY".equalsIgnoreCase(query.toString()) // non-identifier-compare: keyword
                                || !"EXECUTE".equalsIgnoreCase(execute.toString())) { // non-identifier-compare: keyword
                        return false;
                }
                String sqlText = literalCommandText(stmt.getExpression());
                if (sqlText == null) {
                        return false;
                }
                modelManager.collectDynamicSqlHash(stmt);
                if (!option.isAnalyzeDynamicSql()) {
                        recordDynamicSqlSite(stmt, DynamicSqlSite.Kind.OTHER, DynamicSqlSite.Status.UNRESOLVED,
                                        "dynamic SQL inner analysis disabled");
                        return true;
                }
                TGSqlParser sqlparser = createSqlParser(option.getVendor());
                sqlparser.sqltext = sqlText;
                if (parseWithCommentBindings(sqlparser) != 0 || sqlparser.sqlstatements == null
                                || sqlparser.sqlstatements.size() == 0) {
                        return true; // a text that does not parse: nothing it returns is known
                }
                dynamicFoldDepth++;
                try {
                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                        }
                } finally {
                        dynamicFoldDepth--;
                }
                if (sqlparser.sqlstatements.size() == 1 && sqlparser.sqlstatements.get(0) instanceof TSelectSqlStatement) {
                        Object model = modelManager.getModel(sqlparser.sqlstatements.get(0));
                        if (model instanceof ResultSet && ((ResultSet) model).getColumns() != null) {
                                ResultSet resultSet = (ResultSet) model;
                                ResultSet returnResult = modelFactory.createResultSet(stmt, true);
                                for (ResultColumn column : resultSet.getColumns()) {
                                        TObjectName columnName = new TObjectName();
                                        columnName.setString(column.getName());
                                        ResultColumn resultColumn = modelFactory.createResultColumn(returnResult, columnName);
                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                        dataflowRelation.setEffectType(EffectType.select);
                                        dataflowRelation.addSource(new ResultColumnRelationshipElement(column));
                                        dataflowRelation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                }
                                returnResult.setDetermined(resultSet.isDetermined());
                                modelManager.bindFunctionResult(procedureParentAliasKey(stmt), returnResult);
                        }
                }
                return true;
        }

        /** The text of a command written as single-quoted string constants joined with ||, or null. */
        private static String literalCommandText(TExpression expression) {
                java.util.Deque<TExpression> pending = new java.util.ArrayDeque<TExpression>();
                List<TExpression> parts = new ArrayList<TExpression>();
                pending.push(expression);
                while (!pending.isEmpty()) {
                        TExpression e = pending.pop();
                        while (e != null && e.getExpressionType() == EExpressionType.parenthesis_t) {
                                e = e.getLeftOperand();
                        }
                        if (e == null) {
                                return null;
                        }
                        if (e.getExpressionType() == EExpressionType.concatenate_t) {
                                pending.push(e.getRightOperand());
                                pending.push(e.getLeftOperand());
                                continue;
                        }
                        parts.add(e);
                }
                StringBuilder text = new StringBuilder();
                for (TExpression part : parts) {
                        if (part.getExpressionType() != EExpressionType.simple_constant_t || part.getConstantOperand() == null
                                        || part.getConstantOperand().getValueToken() == null) {
                                return null;
                        }
                        String literal = part.getConstantOperand().getValueToken().toString();
                        if (literal.length() < 2 || literal.charAt(0) != '\'' || literal.charAt(literal.length() - 1) != '\'') {
                                return null; // E'...', $$...$$, a number: not a plain string constant
                        }
                        text.append(literal.substring(1, literal.length() - 1).replace("''", "'"));
                }
                return text.toString();
        }

        private void analyzeReturnStmt(TReturnStmt stmt) {
                if (analyzeReturnQueryExecute(stmt)) {
                        return;
                }
                if (stmt.getResultColumnList() != null) {
                        ResultSet returnResult = modelFactory.createResultSet(stmt, true);
                        for (TResultColumn column : stmt.getResultColumnList()) {
                                ResultColumn resultColumn = modelFactory.createResultColumn(returnResult, column);
                                if (stmt.getResultColumnList().size() == 1) bindCurrentRoutineReturn(resultColumn);

                                columnsInExpr visitor = new columnsInExpr();
                                column.getExpr().inOrderTraverse(visitor);

                                List<TObjectName> objectNames = visitor.getObjectNames();
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                List<TParseTreeNode> constants = visitor.getConstants();
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                                }
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.select);
                                }
                                if (objectNames != null && !objectNames.isEmpty()) {
                                        analyzeDataFlowRelation(resultColumn, objectNames, EffectType.select, functions);
                                }
                                if (constants != null && !constants.isEmpty()) {
                                        analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.select, functions);
                                }

                        }

                        String procedureParent = SQLUtil.trimColumnStringQuote(getProcedureParentName(stmt));
                        modelManager.bindFunctionResult(procedureParentAliasKey(stmt), returnResult);
                }
                else if(stmt.getExpression()!=null){
                        TExpression returnExpression = stmt.getExpression();
                        ResultSet returnResult = modelFactory.createResultSet(stmt, true);
                        
                        columnsInExpr visitor = null;
                        List<TSelectSqlStatement> subquerys = null;
                        
                        if (returnExpression.getFunctionCall() != null
                                        && returnExpression.getFunctionCall().getFunctionName().toString().equalsIgnoreCase("table")
                                        && returnExpression.getFunctionCall().getArgs() != null
                                        && returnExpression.getFunctionCall().getArgs().size()>0) {
                                visitor = new columnsInExpr();
                                returnExpression.getFunctionCall().getArgs().getExpression(0).inOrderTraverse(visitor);
                                subquerys = visitor.getSubquerys();
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSelectStmt(subquerys.get(0));
                                        ResultSet resultSet = (ResultSet) modelManager.getModel(subquerys.get(0));
                                        if (resultSet != null && resultSet.getColumns() != null) {
                                                for (ResultColumn column : resultSet.getColumns()) {
                                                        TObjectName columnName = new TObjectName();
                                                        columnName.setString(column.getName());
                                                        ResultColumn resultColumn = modelFactory.createResultColumn(returnResult, columnName);
                                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                        dataflowRelation.setEffectType(EffectType.select);
                                                        dataflowRelation.addSource(new ResultColumnRelationshipElement(column));
                                                        dataflowRelation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                }
                                        }
                                        returnResult.setDetermined(resultSet.isDetermined());
                                        String procedureParent = SQLUtil.trimColumnStringQuote(getProcedureParentName(stmt));
                                        modelManager.bindFunctionResult(procedureParentAliasKey(stmt), returnResult);
                                        return;
                                }
                        }
                        
                        ResultColumn resultColumn = null;
                        if (returnExpression.getExpressionType() == EExpressionType.simple_object_name_t) {
                                TObjectName columnName = DlineageUtil.syntheticStarName();
                                resultColumn = modelFactory.createResultColumn(returnResult, columnName);
                        }
                        else {
                                resultColumn = modelFactory.createResultColumn(returnResult, returnExpression);
                        }

                        visitor = new columnsInExpr();
                        stmt.getExpression().inOrderTraverse(visitor);

                        List<TObjectName> objectNames = visitor.getObjectNames();
                        List<TParseTreeNode> functions = visitor.getFunctions();
                        List<TParseTreeNode> constants = visitor.getConstants();
                        subquerys = visitor.getSubquerys();

                        if (functions != null && !functions.isEmpty()) {
                                analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                        }
                        if (subquerys != null && !subquerys.isEmpty()) {
                                analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.select);
                        }
                        if (objectNames != null && !objectNames.isEmpty()) {
                                DataFlowRelationship relation = analyzeDataFlowRelation(resultColumn, objectNames, EffectType.select, functions);
                                //如果variable对应的不是一个复杂结构，则resultColumn不要设置为*
                                if (relation != null && relation.getTarget().getElement() == resultColumn && relation.getSources().size() == 1) {
                                        Object column = relation.getSources().iterator().next().getElement();
                                        boolean star = true;
                                        if (column instanceof TableColumn && !((TableColumn) column).isStarColumn()) {
                                                star = false;
                                        }
                                        if (column instanceof ResultColumn && !((ResultColumn) column).isStarColumn()) {
                                                star = false;
                                        }
                                        if (!star && returnExpression.getExpressionType() == EExpressionType.simple_object_name_t) {
                                                resultColumn = modelFactory.createResultColumn(returnResult, returnExpression.getObjectOperand());
                                                returnResult.getColumns().clear();
                                                returnResult.addColumn(resultColumn);
                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                        }
                                }
                        }
                        if (constants != null && !constants.isEmpty()) {
                                analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.select, functions);
                        }
                        bindCurrentRoutineReturn(resultColumn);

                        String procedureParent = SQLUtil.trimColumnStringQuote(getProcedureParentName(stmt));
                        if (procedureParent != null) {
                                modelManager.bindFunctionResult(procedureParentAliasKey(stmt), returnResult);
                        }
                }
        }

        private void bindCurrentRoutineReturn(ResultColumn resultColumn) {
                if (!shouldCollectAuthoritativeLineageEvidence()) return;
                TStoredProcedureSqlStatement declaration = ModelBindingManager.getGlobalProcedure();
                Object routine = declaration == null ? null : modelManager.getModel(declaration);
                if (routine instanceof Procedure) {
                        authoritativeEvidenceCollector.bindRoutineReturn((Procedure) routine, resultColumn);
                }
        }

        private void analyzeMssqlReturnStmt(TMssqlReturn stmt) {
                if (stmt.getResultColumnList() != null) {
                        ResultSet returnResult = modelFactory.createResultSet(stmt, true);
                        for (TResultColumn column : stmt.getResultColumnList()) {
                                ResultColumn resultColumn = modelFactory.createResultColumn(returnResult, column);
                                if (stmt.getResultColumnList().size() == 1) bindCurrentRoutineReturn(resultColumn);

                                columnsInExpr visitor = new columnsInExpr();
                                column.getExpr().inOrderTraverse(visitor);

                                List<TObjectName> objectNames = visitor.getObjectNames();
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                List<TParseTreeNode> constants = visitor.getConstants();
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                                }
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.select);
                                }
                                if (objectNames != null && !objectNames.isEmpty()) {
                                        analyzeDataFlowRelation(resultColumn, objectNames, EffectType.select, functions);
                                }
                                if (constants != null && !constants.isEmpty()) {
                                        analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.select, functions);
                                }

                        }

                        String procedureParent = SQLUtil.trimColumnStringQuote(getProcedureParentName(stmt));
                        modelManager.bindFunctionResult(procedureParentAliasKey(stmt), returnResult);
                }
                else if(stmt.getReturnExpr()!=null){
                        TExpression returnExpression = stmt.getReturnExpr();
                        ResultSet returnResult = modelFactory.createResultSet(stmt, true);
                        
                        if (returnExpression.getSubQuery() == null) {
                                ResultColumn resultColumn = modelFactory.createResultColumn(returnResult, returnExpression);
                                columnsInExpr visitor = new columnsInExpr();
                                stmt.getReturnExpr().inOrderTraverse(visitor);

                                List<TObjectName> objectNames = visitor.getObjectNames();
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                List<TParseTreeNode> constants = visitor.getConstants();
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                                }
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.select);
                                }
                                if (objectNames != null && !objectNames.isEmpty()) {
                                        analyzeDataFlowRelation(resultColumn, objectNames, EffectType.select, functions);
                                }
                                if (constants != null && !constants.isEmpty()) {
                                        analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.select, functions);
                                }
                                bindCurrentRoutineReturn(resultColumn);
                        }
                        else {
                                analyzeSelectStmt(returnExpression.getSubQuery());
                                ResultSet subResultSet = (ResultSet)modelManager.getModel(returnExpression.getSubQuery());
                                if (subResultSet != null) {
                                        for (ResultColumn subResultColumn : subResultSet.getColumns()) {
                                                TObjectName objectName = new TObjectName();
                                                objectName.setString(subResultColumn.getName());
                                                ResultColumn resultColumn = modelFactory.createResultColumn(returnResult, objectName);
                                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                dataflowRelation.setEffectType(EffectType.select);
                                                dataflowRelation.addSource(new ResultColumnRelationshipElement(subResultColumn));
                                                dataflowRelation.setTarget(new ResultColumnRelationshipElement(resultColumn));

                                        }
                                        
                                        if(subResultSet.getRelationRows().hasRelation()) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(EffectType.select);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                subResultSet.getRelationRows()));
                                                impactRelation.setTarget(
                                                                new RelationRowsRelationshipElement<ResultSetRelationRows>(returnResult.getRelationRows()));
                                        }
                                }
                        }
                        
                        String procedureParent = SQLUtil.trimColumnStringQuote(getProcedureParentName(stmt));
                        if (procedureParent != null) {
                                modelManager.bindFunctionResult(procedureParentAliasKey(stmt), returnResult);
                        }
                }
                else if (stmt.getSubquery() != null) {
                        analyzeSelectStmt(stmt.getSubquery());
                        ResultSet subResultSet = (ResultSet)modelManager.getModel(stmt.getSubquery());
                        String procedureParent = SQLUtil.trimColumnStringQuote(getProcedureParentName(stmt));
                        if (procedureParent != null && subResultSet!=null) {
                                modelManager.bindFunctionResult(procedureParentAliasKey(stmt), subResultSet);
                        }
                }
        }
        
        /**
         * The column that stands for a composite variable as a WHOLE (#695).
         *
         * <p>A PL/SQL record variable used to be modelled as one opaque column, so
         * "the" column of a variable was always {@code getColumns().get(0)}. Once
         * records expand to per-field columns, {@code get(0)} silently means "an
         * arbitrary field" — the edge that FILLS the record then lands on one
         * field (or, worse, every producer field is fanned onto it). The whole-
         * record binding must instead land on the record's own {@code *} column,
         * which stays distinct per variable instance and can be expanded once the
         * pairing is known.
         */
        private TableColumn compositeBindingColumn(Variable variable) {
                if (variable.getColumns() == null || variable.getColumns().isEmpty()) {
                        return tableStarColumn(variable);
                }
                if (variable.getColumns().size() == 1) {
                        return variable.getColumns().get(0);
                }
                if (variable.isTypeOrderedFields()) {
                        // Fields from the TYPE declaration: the star expands onto exactly
                        // those fields at serialization — every one is genuinely filled.
                        return tableStarColumn(variable);
                }
                // Consumption-shaped fields (pseudo-columns, expression names) carry no
                // per-field meaning; expanding a star over them fans every producer onto
                // every artifact. Keep the historical whole-record binding.
                return variable.getColumns().get(0);
        }

        /**
         * The {@code *} column of {@code table}, created on first use with the
         * expand-star convention (as the %ROWTYPE declaration path does): the
         * serializer expands a relation targeting it onto the sibling fields it
         * star-links, so the edge always cites DECLARED columns — a relationship
         * must never cite a column the model does not declare.
         */
        private TableColumn tableStarColumn(Table table) {
                if (table.getColumns() != null) {
                        for (TableColumn existing : table.getColumns()) {
                                if (existing.isStarColumn()) {
                                        return existing;
                                }
                        }
                }
                TableColumn starColumn = modelFactory.createTableColumn(table, starObjectName(), true);
                starColumn.setShowStar(false);
                starColumn.setExpandStar(true);
                return starColumn;
        }

        private TObjectName starObjectName() {
                TObjectName starColumn = DlineageUtil.syntheticStarName();
                return starColumn;
        }

        private void analyzeFetchStmt(TFetchStmt stmt) {
                if (stmt.getVariableNames() != null) {
                        for (int i = 0; i < stmt.getVariableNames().size(); i++) {
                                TExpression variableExpression = stmt.getVariableNames().getExpression(i);
                                if (variableExpression.getExpressionType() == EExpressionType.simple_object_name_t) {
                                        TObjectName columnObject = variableExpression.getObjectOperand();
                                        if (columnObject.getDbObjectType() == EDbObjectType.variable) {
                                                continue;
                                        }

                                        if (columnObject.getColumnNameOnly().startsWith("@") && (option.getVendor() == EDbVendor.dbvmssql
                                                        || option.getVendor() == EDbVendor.dbvazuresql)) {
                                                continue;
                                        }

                                        if (columnObject.getColumnNameOnly().startsWith(":") && (option.getVendor() == EDbVendor.dbvhana
                                                        || option.getVendor() == EDbVendor.dbvteradata)) {
                                                continue;
                                        }

                                        Variable cursorVariable = modelFactory.createReferencedVariable(columnObject);
                                        cursorVariable.setSubType(SubType.record);
                                        if (cursorVariable.isDetermined()) {
                                                if (stmt.getCursorName() != null) {
                                                        // The cursor FETCH names: declared here, in an enclosing routine or in the package.
                                                        Table cursor = modelManager.visibleLocal(withoutColon(stmt.getCursorName().toString()),
                                                                        LocalSymbolKey.Kind.CURSOR);
                                                        if (cursor != null) {
                                                                // FETCH ... INTO binds POSITIONALLY (#695): the k-th
                                                                // cursor column fills the k-th record field, whatever
                                                                // either is called. Matching by name paired
                                                                // like-named columns that are NOT each other's source
                                                                // and, when nothing matched, fanned every cursor
                                                                // column onto every field — edges the SQL never
                                                                // asserts. A field the cursor's known width cannot
                                                                // account for keeps the cursor's own * as its source:
                                                                // filled, but by an unresolved component.
                                                                List<TableColumn> recordFields = cursorVariable.getColumns();
                                                                List<TableColumn> cursorColumns = cursor.getColumns();
                                                                if (columnObject.toString().indexOf('.') != -1) {
                                                                        // FETCH ... INTO rec.field names its target
                                                                        // explicitly (#695): bind THAT field to the
                                                                        // cursor column at this INTO position —
                                                                        // iterating every field here fanned each
                                                                        // cursor column onto the whole record.
                                                                        TableColumn namedField = modelFactory.createTableColumn(cursorVariable,
                                                                                        columnObject, true);
                                                                        if (namedField != null) {
                                                                                DataFlowRelationship dottedRelation = modelFactory.createDataFlowRelation();
                                                                                dottedRelation.setEffectType(EffectType.cursor);
                                                                                if (cursorColumns != null && i < cursorColumns.size()) {
                                                                                        dottedRelation.addSource(
                                                                                                        new TableColumnRelationshipElement(cursorColumns.get(i)));
                                                                                } else {
                                                                                        dottedRelation.addSource(
                                                                                                        new TableColumnRelationshipElement(tableStarColumn(cursor)));
                                                                                }
                                                                                dottedRelation.setTarget(new TableColumnRelationshipElement(namedField));
                                                                        }
                                                                        continue;
                                                                }
                                                                boolean ordinalPairing = stmt.getVariableNames().size() == 1
                                                                                && cursorColumns != null && !cursorColumns.isEmpty()
                                                                                && cursorVariable.isTypeOrderedFields();
                                                                // A SCALAR at INTO position i pairs with cursor
                                                                // column i when the widths agree — positional by
                                                                // the INTO list itself, no type order involved.
                                                                boolean intoPositional = recordFields.size() == 1
                                                                                && cursorColumns != null
                                                                                && cursorColumns.size() == stmt.getVariableNames().size();
                                                                boolean hasRealField = false;
                                                                for (TableColumn field : recordFields) {
                                                                        if (field.getName() != null && !field.isStarColumn()) {
                                                                                hasRealField = true;
                                                                                break;
                                                                        }
                                                                }
                                                                int fieldOrdinal = 0;
                                                                for (int k = 0; k < recordFields.size(); k++) {
                                                                        TableColumn variableProperty = recordFields.get(k);
                                                                        if (variableProperty.isStarColumn() && hasRealField) {
                                                                                // With real fields present the wildcard is a
                                                                                // binding artifact (codex-696 F2). When it is
                                                                                // the ONLY column it IS the whole-record
                                                                                // binding — skipping it dropped every fill
                                                                                // whose consumption comes after the FETCH.
                                                                                continue;
                                                                        }
                                                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                                        dataflowRelation.setEffectType(EffectType.cursor);
                                                                        if (ordinalPairing && fieldOrdinal < cursorColumns.size()) {
                                                                                dataflowRelation.addSource(
                                                                                                new TableColumnRelationshipElement(cursorColumns.get(fieldOrdinal)));
                                                                        } else if (intoPositional) {
                                                                                dataflowRelation.addSource(
                                                                                                new TableColumnRelationshipElement(cursorColumns.get(i)));
                                                                        } else if (stmt.getVariableNames().size() > 1) {
                                                                                dataflowRelation.addSource(
                                                                                                new TableColumnRelationshipElement(tableStarColumn(cursor), i));
                                                                        } else {
                                                                                dataflowRelation.addSource(
                                                                                                new TableColumnRelationshipElement(tableStarColumn(cursor)));
                                                                        }
                                                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(variableProperty));
                                                                        fieldOrdinal++;
                                                                }
                                                        }
                                                }
                                                
                                        } else {
                                                TableColumn variableProperty = null;
                                                if (stmt.getVariableNames().size() == 1) {
                                                        if (cursorVariable.getColumns() == null || cursorVariable.getColumns().isEmpty()) {
                                                                TObjectName starColumn = DlineageUtil.syntheticStarName();
                                                                variableProperty = modelFactory.createTableColumn(cursorVariable, starColumn, true);
                                                        } else {
                                                                variableProperty = cursorVariable.getColumns().get(0);
                                                        }
                                                } else {
                                                        variableProperty = modelFactory.createTableColumn(cursorVariable, columnObject, true);
                                                }

                                                if (stmt.getCursorName() != null) {
                                                        // The cursor FETCH names: declared here, in an enclosing routine or in the package.
                                                        Table cursor = modelManager.visibleLocal(withoutColon(stmt.getCursorName().toString()),
                                                                        LocalSymbolKey.Kind.CURSOR);
                                                        if (cursor != null) {
                                                                for (int j = 0; j < cursor.getColumns().size(); j++) {
                                                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                                        dataflowRelation.setEffectType(EffectType.cursor);
                                                                        if (stmt.getVariableNames().size() == 1) {
                                                                                dataflowRelation.addSource(
                                                                                                new TableColumnRelationshipElement(cursor.getColumns().get(j)));
                                                                        } else {
                                                                                dataflowRelation.addSource(
                                                                                                new TableColumnRelationshipElement(cursor.getColumns().get(j), i));
                                                                        }
                                                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(variableProperty));
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        private void analyzeFetchStmt(TMssqlFetch stmt) {
                if (stmt.getVariableNames() != null) {
                        for (int i = 0; i < stmt.getVariableNames().size(); i++) {
                                TObjectName columnObject = stmt.getVariableNames().getObjectName(i);
                                Variable cursorVariable = modelFactory.createReferencedVariable(columnObject);
                                cursorVariable.setCreateTable(true);
                                cursorVariable.setSubType(SubType.record);
                                TableColumn variableProperty = null;
                                if (stmt.getVariableNames().size() == 1) {
                                        if (cursorVariable.getColumns() == null || cursorVariable.getColumns().isEmpty()) {
                                                TObjectName starColumn = DlineageUtil.syntheticStarName();
                                                variableProperty = modelFactory.createTableColumn(cursorVariable, starColumn, true);
                                        } else {
                                                variableProperty = cursorVariable.getColumns().get(0);
                                        }
                                } else {
                                        variableProperty = modelFactory.createTableColumn(cursorVariable, columnObject, true);
                                }

                                if (stmt.getCursorName() != null) {
                                        // The cursor FETCH names: declared here, in an enclosing routine or in the package.
                                        Table cursor = modelManager.visibleLocal(withoutColon(stmt.getCursorName().toString()),
                                                        LocalSymbolKey.Kind.CURSOR);
                                        if (cursor != null) {
                                                for (int j = 0; j < cursor.getColumns().size(); j++) {
                                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                        dataflowRelation.setEffectType(EffectType.cursor);
                                                        if (stmt.getVariableNames().size() == 1) {
                                                                dataflowRelation
                                                                                .addSource(new TableColumnRelationshipElement(cursor.getColumns().get(j)));
                                                        } else {
                                                                dataflowRelation
                                                                                .addSource(new TableColumnRelationshipElement(cursor.getColumns().get(j), i));
                                                        }
                                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(variableProperty));
                                                }
                                        }
                                }
                        }

                }
        }

        private void analyzeLoopStmt(TLoopStmt stmt) {

                if (stmt.getCursorName() != null && stmt.getIndexName() != null) {
                        modelManager.bindCursorIndex(stmt.getIndexName(), stmt.getCursorName());
                }

                if (stmt.getRecordName() != null && stmt.getSubquery() != null) {
                        Variable cursorTempTable = modelFactory.createCursor(stmt);
                        cursorTempTable.setVariable(true);
                        cursorTempTable.setSubType(SubType.cursor);
                        modelManager.bindCursorModel(stmt, cursorTempTable);
                        analyzeSelectStmt(stmt.getSubquery());

                        TableColumn cursorColumn = null;
                        if (cursorTempTable.getColumns() == null || cursorTempTable.getColumns().isEmpty()) {
                                TObjectName starColumn = DlineageUtil.syntheticStarName();
                                cursorColumn = modelFactory.createTableColumn(cursorTempTable, starColumn, true);
                        } else {
                                cursorColumn = cursorTempTable.getColumns().get(0);
                        }


                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt.getSubquery());
                        if (resultSetModel != null) {
                                for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                        ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                        dataflowRelation.setEffectType(EffectType.cursor);
                                        dataflowRelation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(cursorColumn));
                                }
                        }
                }

                for (int i = 0; i < stmt.getStatements().size(); i++) {
                        analyzeCustomSqlStmt(stmt.getStatements().get(i));
                }
        }

        private void analyzeForStmt(TForStmt stmt) {
                if (stmt.getSubquery() == null) {
                        return;
                }

                Variable cursorTempTable = modelFactory.createCursor(stmt);
                cursorTempTable.setVariable(true);
                cursorTempTable.setSubType(SubType.cursor);
                cursorTempTable.setCreateTable(true);
                modelManager.bindCursorModel(stmt, cursorTempTable);
                analyzeSelectStmt(stmt.getSubquery());

                TableColumn cursorColumn = null;
                if (cursorTempTable.getColumns() == null || cursorTempTable.getColumns().isEmpty()) {
                        TObjectName starColumn = DlineageUtil.syntheticStarName();
                        cursorColumn = modelFactory.createTableColumn(cursorTempTable, starColumn, true);
                } else {
                        cursorColumn = cursorTempTable.getColumns().get(0);
                }


                ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt.getSubquery());
                if (resultSetModel != null) {
                        for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                dataflowRelation.setEffectType(EffectType.cursor);
                                dataflowRelation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                dataflowRelation.setTarget(new TableColumnRelationshipElement(cursorColumn));
                        }
                }

                if (stmt.getStatements() != null && stmt.getStatements().size() > 0) {
                        for (int i = 0; i < stmt.getStatements().size(); i++) {
                                analyzeCustomSqlStmt(stmt.getStatements().get(i));
                        }
                }
        }

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

        /**
         * The column of a record's own table that a field of the record names, for a record declared as a row of that
         * table. A field written {@code rec.field} (as in {@code SELECT ... INTO rec.field}) is a reference to the
         * variable: it names no column and has no identity, so the column is named by the field's own segment, as the
         * table spells it. Any other field name is already a column's.
         */
        private TObjectName recordFieldColumnName(TObjectName field) {
                if (field != null && field.getDbObjectType() == EDbObjectType.variable && field.getPartToken() == null
                                && field.getSchemaToken() != null && field.getObjectToken() != null) {
                        return TObjectName.createObjectName(option.getVendor(), EDbObjectType.column, field.getObjectToken());
                }
                return field;
        }

        /**
         * Resolve a declared name visible from the CURRENT scope (#695): a TYPE
         * declared at package level is visible from every nested procedure, but
         * a same-scope lookup misses it and the declaring variable silently falls
         * back to one opaque variant column — the record-fill edges then have no
         * per-field target and are lost. Walk the scope chain outward
         * (procedure → enclosing procedures → package → top level); never create.
         */
        private Variable resolveVariableInScope(String name) {
                if (SQLUtil.isEmpty(name)) {
                        return null;
                }
                Table found = modelManager.lookupVisibleLocalSymbol(
                                LocalSymbolKey.of(null, withoutColon(name), LocalSymbolKey.Kind.TYPE),
                                stmtStack.isEmpty() ? null : stmtStack.peek(), true);
                return found instanceof Variable ? (Variable) found : null;
        }

        /**
         * Materialize the fields of a record-typed FORMAL argument from its
         * declared type before binding an actual to it (#695). Without this the
         * formal is one opaque column and the argument-fill edge either lands on
         * an arbitrary field or is lost. Field order follows the TYPE declaration
         * unless consumption already created some fields (name-deduped), so
         * ordinal use of formal fields must not rely on this method alone.
         */
        private void materializeArgumentFields(Variable variable, Argument argument) {
                if (variable == null || argument == null || argument.getDataType() == null) {
                        return;
                }
                if (variable.isDetermined() && variable.getColumns() != null && variable.getColumns().size() > 1) {
                        return;
                }
                Variable typeModel = resolveVariableInScope(argument.getDataType().getDataTypeName());
                if (typeModel == null || typeModel == variable || !typeModel.isDetermined()
                                || typeModel.getColumns() == null || typeModel.getColumns().isEmpty()) {
                        return;
                }
                // Fields created by earlier consumption sit BEFORE the type fields we
                // append here, so the column list is only in type order when nothing
                // preceded it (codex-696 F2). Ordinal pairing must not trust a mixed
                // list.
                boolean hadRealFields = false;
                if (variable.getColumns() != null) {
                        for (TableColumn existing : variable.getColumns()) {
                                if (existing.getName() != null && !existing.isStarColumn()) {
                                        hadRealFields = true;
                                        break;
                                }
                        }
                }
                for (TableColumn typeField : typeModel.getColumns()) {
                        if (typeField.getName() == null || typeField.isStarColumn()) {
                                continue;
                        }
                        TObjectName fieldName = new TObjectName();
                        fieldName.setString(typeField.getName());
                        modelFactory.createTableColumn(variable, fieldName, true);
                }
                // A formal declared before this had only its wildcard column; now that
                // the real fields exist, a relation binding the record as a whole must
                // expand onto them at serialization instead of citing the bare star.
                if (variable.getColumns() != null) {
                        for (TableColumn existing : variable.getColumns()) {
                                if (existing.isStarColumn()) {
                                        existing.setShowStar(false);
                                        existing.setExpandStar(true);
                                }
                        }
                }
                variable.setDetermined(true);
                if (!hadRealFields) {
                        variable.setTypeOrderedFields(true);
                }
        }

        /**
         * The variable model of a callee's FORMAL argument, shaped for binding
         * (#695). {@code createVariable(Procedure, name, false)} deliberately
         * refuses a record-typed formal it recovers through the declaration-time
         * scope key (one wildcard column = nothing exact to bind to). Recover the
         * variable anyway, materialize its fields from the declared type, and only
         * bind when a real field emerged — otherwise keep the historical refusal.
         */
        private Variable resolveFormalVariable(Procedure callee, Argument argument) {
                Variable variable = modelFactory.createVariable(callee, argument.getName(), false);
                if (variable != null) {
                        materializeArgumentFields(variable, argument);
                        return variable;
                }
                Variable recovered = modelFactory.findFormalVariable(callee, argument.getName());
                if (recovered == null) {
                        return null;
                }
                materializeArgumentFields(recovered, argument);
                if (recovered.getColumns() != null) {
                        for (TableColumn column : recovered.getColumns()) {
                                if (!column.isStarColumn()) {
                                        return recovered;
                                }
                        }
                }
                return null;
        }

        private void analyzeVarDeclStmt(TVarDeclStmt stmt) {
                TTypeName typeName = stmt.getDataType();
                if (typeName != null && typeName.toString().toUpperCase(Locale.ROOT).indexOf("ROWTYPE") != -1) {
                        Variable cursorVariable = modelFactory.createVariable(stmt.getElementName());
                        cursorVariable.setSubType(SubType.record_type);

                        Table variableTable = modelFactory.createRowTypeAnchor(typeName.getDataTypeName());
                        cursorVariable.setRowTypeAnchor(variableTable);
                        if(!variableTable.isCreateTable()) {
                                TObjectName starColumn1 = DlineageUtil.syntheticStarName();
                                TableColumn variableTableStarColumn = modelFactory.createTableColumn(variableTable, starColumn1, true);
                                variableTableStarColumn.setShowStar(false);
                                variableTableStarColumn.setExpandStar(true);

                                TObjectName starColumn = DlineageUtil.syntheticStarName();
                                TableColumn variableProperty = modelFactory.createTableColumn(cursorVariable, starColumn, true);
                                variableProperty.setShowStar(false);
                                variableProperty.setExpandStar(true);

                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                dataflowRelation.setEffectType(EffectType.rowtype);
                                dataflowRelation.addSource(new TableColumnRelationshipElement(variableTableStarColumn));
                                dataflowRelation.setTarget(new TableColumnRelationshipElement(variableProperty));
                        } else {
                                for (TableColumn sourceColumn : variableTable.getColumns()) {
                                        String columnName = sourceColumn.getName();
                                        TObjectName targetColumn = new TObjectName();
                                        targetColumn.setString(columnName);
                                        TableColumn variableProperty = modelFactory.createTableColumn(cursorVariable, targetColumn, true);
                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                        dataflowRelation.setEffectType(EffectType.rowtype);
                                        dataflowRelation.addSource(new TableColumnRelationshipElement(sourceColumn));
                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(variableProperty));
                                }
                        }
                } else if (stmt.getElementName() != null) {
                        Variable variable = modelFactory.createVariable(stmt.getElementName());
                        variable.setCreateTable(true);
                        variable.setSubType(SubType.record);
                        TableColumn tableColumn = null;
                        if (stmt.getDataType() != null && (resolveVariableInScope(stmt.getDataType().getDataTypeName())!=null || isCursorType(stmt.getDataType().getDataTypeName()))) {
                                Variable cursorVariable = resolveVariableInScope(stmt.getDataType().getDataTypeName());
                                if (cursorVariable != null) {
                                        if (cursorVariable.getSubType() == SubType.record_type) {
                                                variable.setSubType(SubType.record_type);
                                        }
                                        if(cursorVariable.isDetermined()) {
                                                for (int k = 0; k < cursorVariable.getColumns().size(); k++) {
                                                        TableColumn sourceColumn = cursorVariable.getColumns().get(k);
                                                        TObjectName objectName = new TObjectName();
                                                        objectName.setString(sourceColumn.getName());
                                                        tableColumn = modelFactory.createTableColumn(variable, objectName, true);
                                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                        dataflowRelation.setEffectType(EffectType.cursor);
                                                        dataflowRelation
                                                                        .addSource(new TableColumnRelationshipElement(sourceColumn));
                                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                }
                                                variable.setDetermined(true);
                                                variable.setTypeOrderedFields(true);
                                                return;
                                        }
                                        else {
                                                TObjectName objectName = DlineageUtil.syntheticStarName();
                                                tableColumn = modelFactory.createTableColumn(variable, objectName, true);
                                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                dataflowRelation.setEffectType(EffectType.cursor);
                                                dataflowRelation
                                                                .addSource(new TableColumnRelationshipElement(cursorVariable.getColumns().get(0)));
                                                dataflowRelation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                        }
                                }
                                else {
                                        TObjectName objectName = DlineageUtil.syntheticStarName();
                                        tableColumn = modelFactory.createTableColumn(variable, objectName, true);                                       
                                }
                        } else {
                                tableColumn = modelFactory.createTableColumn(variable, stmt.getElementName(), true);
                                tableColumn.setVariant(true);
                        }

                        if (stmt.getDefaultValue() != null) {
                                columnsInExpr visitor = new columnsInExpr();
                                stmt.getDefaultValue().inOrderTraverse(visitor);
                                List<TObjectName> objectNames = visitor.getObjectNames();
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                List<TParseTreeNode> constants = visitor.getConstants();
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(tableColumn, functions, EffectType.function);
                                }
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(tableColumn, subquerys, EffectType.select);
                                }
                                if (objectNames != null && !objectNames.isEmpty()) {
                                        analyzeDataFlowRelation(tableColumn, objectNames, EffectType.select, functions);
                                }
                                if (constants != null && !constants.isEmpty()) {
                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select, functions);
                                }
                        }
                        
                        
                }
        }

        private boolean isCursorType(String dataTypeName) {
                if (dataTypeName != null && dataTypeName.toLowerCase(Locale.ROOT).contains("cursor")) {
                        return true;
                }
                return false;
        }

        private void analyzeSetStmt(TSetStmt stmt) {
                TExpression right = stmt.getVariableValue();
                TObjectName columnObject = stmt.getVariableName();
                if (columnObject != null) {
                        TableColumn tableColumn = null;
                        Variable tableModel;
                        if (columnObject.toString().indexOf(".") != -1) {
                                List<String> splits = SQLUtil.parseNames(columnObject.toString());
                                tableModel = modelFactory.createReferencedVariable(splits.get(splits.size() - 2), true);
                        } else {
                                tableModel = modelFactory.createReferencedVariable(columnObject);
                        }
                        tableModel.setCreateTable(true);
                        tableModel.setSubType(SubType.record);

                        if (tableModel.getColumns() == null || tableModel.getColumns().isEmpty()) {
                                tableColumn = modelFactory.createTableColumn(tableModel, columnObject, true);
                        } else {
                                tableColumn = tableModel.getColumns().get(0);
                        }

                        if (tableColumn != null && right!=null) {
                                columnsInExpr visitor = new columnsInExpr();
                                right.inOrderTraverse(visitor);
                                List<TObjectName> objectNames = visitor.getObjectNames();
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                List<TParseTreeNode> constants = visitor.getConstants();
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(tableColumn, functions, EffectType.function);
                                }
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(tableColumn, subquerys, EffectType.select);
                                }
                                if (objectNames != null && !objectNames.isEmpty()) {
                                        analyzeDataFlowRelation(tableColumn, objectNames, EffectType.select, functions);
                                }
                                if (constants != null && !constants.isEmpty()) {
                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select, functions);
                                }
                                
                                if(columnObject.toString().equalsIgnoreCase("search_path") && !constants.isEmpty()) {
                                        ModelBindingManager.setGlobalSchema(constants.get(0).toString());
                                }
                        }
                }

                if(stmt.getAssignments()!=null){
                        for (int i = 0; i < stmt.getAssignments().size(); i++) {
                                TSetAssignment assignStmt = stmt.getAssignments().getElement(i);
                                analyzeSetAssignmentStmt(assignStmt);
                        }
                }
        }

        private void analyzeSetAssignmentStmt(TSetAssignment stmt) {
                TExpression right = stmt.getParameterValue();
                TObjectName columnObject = stmt.getParameterName();
                if (columnObject != null) {
                        TableColumn tableColumn = null;
                        Variable tableModel;
                        if (columnObject.toString().indexOf(".") != -1) {
                                List<String> splits = SQLUtil.parseNames(columnObject.toString());
                                tableModel = modelFactory.createReferencedVariable(splits.get(splits.size() - 2), true);
                        } else {
                                tableModel = modelFactory.createReferencedVariable(columnObject);
                        }
                        tableModel.setCreateTable(true);
                        tableModel.setSubType(SubType.record);
                        if (tableModel.getColumns() == null || tableModel.getColumns().isEmpty()) {
                                tableColumn = modelFactory.createTableColumn(tableModel, columnObject, true);
                        } else {
                                tableColumn = tableModel.getColumns().get(0);
                        }

                        if (tableColumn != null && right!=null) {
                                columnsInExpr visitor = new columnsInExpr();
                                right.inOrderTraverse(visitor);
                                List<TObjectName> objectNames = visitor.getObjectNames();
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                List<TParseTreeNode> constants = visitor.getConstants();
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(tableColumn, functions, EffectType.function);
                                }
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(tableColumn, subquerys, EffectType.select);
                                }
                                if (objectNames != null && !objectNames.isEmpty()) {
                                        analyzeDataFlowRelation(tableColumn, objectNames, EffectType.select, functions);
                                }
                                if (constants != null && !constants.isEmpty()) {
                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select, functions);
                                }

                                if(columnObject.toString().equalsIgnoreCase("search_path") && !constants.isEmpty()) {
                                        ModelBindingManager.setGlobalSchema(constants.get(0).toString());
                                }
                        }
                }
        }

        private void analyzeMssqlSetStmt(TMssqlSet stmt) {
                TExpression right = stmt.getVarExpr();
                TObjectName columnObject = stmt.getVarName();
                if (columnObject != null) {
                        TableColumn tableColumn = null;
                        Variable tableModel;
                        if (columnObject.toString().indexOf(".") != -1) {
                                List<String> splits = SQLUtil.parseNames(columnObject.toString());
                                tableModel = modelFactory.createReferencedVariable(splits.get(splits.size() - 2), true);
                        } else {
                                tableModel = modelFactory.createReferencedVariable(columnObject);
                        }
                        tableModel.setCreateTable(true);
                        tableModel.setSubType(SubType.record);
                        if (tableModel.getColumns() == null || tableModel.getColumns().isEmpty()) {
                                tableColumn = modelFactory.createTableColumn(tableModel, columnObject, true);
                        }
                        else {
                                tableColumn = tableModel.getColumns().get(0);
                        }

                        if (tableColumn != null && right!=null) {
                                columnsInExpr visitor = new columnsInExpr();
                                right.inOrderTraverse(visitor);
                                List<TObjectName> objectNames = visitor.getObjectNames();
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                List<TParseTreeNode> constants = visitor.getConstants();
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(tableColumn, functions, EffectType.function);
                                }
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(tableColumn, subquerys, EffectType.select);
                                }
                                if (objectNames != null && !objectNames.isEmpty()) {
                                        analyzeDataFlowRelation(tableColumn, objectNames, EffectType.select, functions);
                                }
                                if (constants != null && !constants.isEmpty()) {
                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select, functions);
                                }

                                if(columnObject.toString().equalsIgnoreCase("search_path") && !constants.isEmpty()) {
                                        ModelBindingManager.setGlobalSchema(constants.get(0).toString());
                                }
                        }
                        else if(tableColumn!=null && stmt.getSubquery()!=null){
                                analyzeCustomSqlStmt(stmt.getSubquery());
                                analyzeSubqueryDataFlowRelation(tableColumn, Arrays.asList(stmt.getSubquery()), EffectType.select);
                        }
                }
        }

        /**
         * Oracle analog of the T-SQL default-path evaluation (plan Phase 5): when the
         * parser's token fold left an EXECUTE IMMEDIATE partial (parameter placeholders)
         * or empty, run the AST interpreter over the file's statements — same-file
         * literal calls bind parameters naturally — plus literal caller statements
         * harvested from OTHER files of a multi-file analysis. The interpreter stores
         * evaluated text on each TExecImmeStmt (getEvaluatedDynamicSQLs), which
         * getDynamicSQL()/getDynamicStatements() then prefer over the token fold; the
         * existing placeholder-contamination classifier keeps half-bound results honest.
         * Best-effort: any interpreter failure leaves the token-fold behavior intact.
         */
        private void maybeEvaluatePlsqlDynamicSql(TExecImmeStmt execImmeStmt) {
                if (option.getVendor() != EDbVendor.dbvoracle) {
                        return;
                }
                if (!execImmeStmt.getEvaluatedDynamicSQLs().isEmpty()) {
                        return;
                }
                if (execImmeStmt.getDynamicSQL() != null && !execImmeStmt.isDynamicSQLPartial()) {
                        // Fully folded already — do not disturb resolved sites.
                        return;
                }
                TGSqlParser owner = execImmeStmt.getGsqlparser();
                if (owner == null || owner.getSqlstatements() == null) {
                        return;
                }
                String ownText = owner.sqltext;
                if (ownText == null || !plsqlEvaluatedTexts.add(ownText)) {
                        return; // one interpreter run per analysis unit
                }
                try {
                        // Definitions plus fully-literal-vetted caller statements only (same-file
                        // first, then cross-file): a caller passing a variable would make the
                        // interpreter fold the unevaluated operand to an EMPTY string, silently
                        // corrupting object names - such callers never enter the list. Empty
                        // list = no vetted caller anywhere = nothing to bind, skip evaluation.
                        List<TCustomSqlStatement> toInterpret = gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                        .plsqlInterpretationStatements(owner.getSqlstatements(), ownText,
                                                        routineCatalog, 4);
                        if (toInterpret.isEmpty()) {
                                return;
                        }
                        TStatementList combined = new TStatementList();
                        for (TCustomSqlStatement stmt : toInterpret) {
                                combined.add(stmt);
                        }
                        TSQLEnv evalEnv = new TSQLEnv(EDbVendor.dbvoracle) {
                                @Override
                                public void initSQLEnv() {
                                }
                        };
                        new gudusoft.gsqlparser.compiler.TASTEvaluator(combined,
                                        new gudusoft.gsqlparser.compiler.TGlobalScope(evalEnv)).eval();
                } catch (RuntimeException ex) {
                        // interpretation is best-effort; token-fold behavior remains
                } catch (java.lang.Error err) {
                        if (err instanceof ThreadDeath) {
                                throw (ThreadDeath) err;
                        }
                        // e.g. StackOverflow on pathological nesting — keep the analysis alive
                }
        }

        /**
         * Default-path dynamic-SQL evaluation (plan Phase 4a): when the token-level fold
         * left an EXEC / sp_executesql / EXEC(@var) site opaque, abstractly evaluate the
         * enclosing procedure's string building with no call-site bindings and try to
         * materialize this site's SQL. Returns null when no usable text was obtained.
         */
        private gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite evaluatedDynamicSqlFor(
                        TCustomSqlStatement execStmt) {
                if (option.getVendor() != EDbVendor.dbvmssql) {
                        return null;
                }
                // Prefer the first fully-concrete materialization; otherwise the first
                // usable partial text; otherwise the first entry (carries the reason).
                gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite best = null;
                for (gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite candidate : selectVariants(execStmt)) {
                        if (candidate.sqlText != null && !candidate.partial) {
                                return candidate;
                        }
                        if (best == null || (best.sqlText == null && candidate.sqlText != null)) {
                                best = candidate;
                        }
                }
                return best;
        }

        /**
         * Why every evaluated variant of {@code execStmt} is SQL NULL for certain (a query over a literal relation
         * returned no row), so the site runs nothing on any of them; null when a variant may run something, or there is
         * no evaluation (Mantis 4962).
         */
        private String provenNullReasonOf(TCustomSqlStatement execStmt) {
                if (option.getVendor() != EDbVendor.dbvmssql) {
                        return null;
                }
                String reason = null;
                for (gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site : selectVariants(execStmt)) {
                        if (site.provenNullReason == null) {
                                return null;
                        }
                        if (reason == null) {
                                reason = site.provenNullReason;
                        }
                }
                return reason;
        }

        /**
         * The evaluated variants of {@code execStmt} the default analysis uses, in variant order (Mantis 4962): the
         * procedure's variants that hold the site; when bindings reached the site and they stand for every call of the
         * procedure in the analysis, the bound ones only, even when none of them gives usable text: the unbound
         * evaluation is then what a caller nobody wrote would see. When some call is not represented (over the cap, not
         * bound, in a routine body, of uncertain ownership), the unbound variants stand for it and stay.
         */
        private List<gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite> selectVariants(TCustomSqlStatement execStmt) {
                List<gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite> candidates = new ArrayList<gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>();
                TCustomSqlStatement proc = option.getVendor() == EDbVendor.dbvmssql ? enclosingStoredProcedure() : null;
                if (proc == null) {
                        return candidates;
                }
                DynamicEvaluation evaluation = dynamicEvaluationOf(proc);
                if (evaluation.presetsRejected) {
                        // the presets bind the procedure but cannot be evaluated: no variant stands in for them
                        return candidates;
                }
                boolean bound = false;
                for (Map<TCustomSqlStatement, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite> variant : evaluation.variants) {
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite candidate = variant.get(execStmt);
                        if (candidate != null) {
                                candidates.add(candidate);
                                bound |= candidate.bindingSource.getKind() != gudusoft.gsqlparser.dlineage.dynamicsql.BindingSource.Kind.NONE;
                        }
                }
                if (bound && evaluation.bindingsExhaustive) {
                        for (Iterator<gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite> it = candidates.iterator(); it.hasNext();) {
                                if (it.next().bindingSource.getKind() == gudusoft.gsqlparser.dlineage.dynamicsql.BindingSource.Kind.NONE) {
                                        it.remove();
                                }
                        }
                }
                return candidates;
        }

        /** The innermost stored procedure on the statement stack, or null outside one. */
        private TCustomSqlStatement enclosingStoredProcedure() {
                for (int i = stmtStack.size() - 1; i >= 0; i--) {
                        if (stmtStack.get(i) instanceof TStoredProcedureSqlStatement) {
                                return stmtStack.get(i);
                        }
                }
                return null;
        }

        /**
         * The procedure's dynamic-SQL evaluation, built on first use: no bindings first, then one group of variants
         * per call-site binding set, same-file callers before the other units of the analysis (cap 4 overall). Each
         * step stands alone: a step that throws leaves the others' variants in place and becomes a note naming the
         * step and the exception, which every site of the procedure reports, rather than silently cutting the
         * evaluation short (Mantis 4962). Calls that name the procedure but are not bound are noted the same way.
         */
        private DynamicEvaluation dynamicEvaluationOf(TCustomSqlStatement proc) {
                DynamicEvaluation evaluation = dynamicEvalCache.get(proc);
                if (evaluation != null) {
                        return evaluation;
                }
                evaluation = new DynamicEvaluation();
                dynamicEvalCache.put(proc, evaluation);
                EDbVendor vendor = option.getVendor();
                // two variables the catalog's identifier rules keep apart but that differ only in case would share a value
                String collision = gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.caseCollision(proc, sqlenv);
                if (collision != null) {
                        evaluation.note("the dynamic SQL of the procedure is not evaluated: " + collision);
                        evaluation.presetsRejected = true;
                        evaluation.bindingsExhaustive = true;
                        return evaluation;
                }
                try {
                        evaluation.variants.addAll(gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                        .materializeSiteVariants(proc, vendor, null, dynamicLineageOptions()));
                } catch (RuntimeException ex) {
                        evaluation.note(dynamicEvaluationFailure("dynamic SQL evaluation without call-site bindings", ex));
                }
                // Values preset in the catalog for the parameters (Mantis 4962) bind the procedure ahead of its calls in
                // the analysis: they stand for every call, which are then not used.
                Map<String, gudusoft.gsqlparser.dlineage.dynamicsql.SqlValue> presets = null;
                try {
                        presets = gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.presetBindings(proc, sqlenv,
                                        null, null);
                } catch (RuntimeException ex) {
                        evaluation.note(dynamicEvaluationFailure("reading the parameter presets of the catalog", ex));
                }
                if (presets != null && presets.size() > dynamicLineageOptions().getMaxBindings()) {
                        evaluation.note("the presets of the procedure give " + presets.size() + " bindings, more than maxBindings("
                                        + dynamicLineageOptions().getMaxBindings() + "): its dynamic SQL is not evaluated with them");
                        evaluation.presetsRejected = true;
                        evaluation.bindingsExhaustive = true;
                        return evaluation;
                }
                if (presets != null) {
                        try {
                                evaluation.variants.addAll(gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                                .materializeSiteVariants(proc, vendor, presets, dynamicLineageOptions(),
                                                                gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.presetSource(proc,
                                                                                presets)));
                        } catch (RuntimeException ex) {
                                evaluation.note(dynamicEvaluationFailure("dynamic SQL evaluation with the preset parameters", ex));
                        }
                        evaluation.bindingsExhaustive = true;
                        noteCallsNotUsed(evaluation, proc);
                        return evaluation;
                }
                // Call-site binding discovery (plan Phase 2/4a): literal EXEC calls to
                // this proc in the same file supply parameter values that can turn a
                // placeholder-bearing template into fully-known SQL.
                int bindingSets = 0;
                gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.CallSiteDiscovery sameFile = null;
                try {
                        // a call whose actuals are not literals is bound through its caller: the catalog's presets and the other
                        // units bind the caller's own parameters (Mantis 4962)
                        sameFile = gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.discoverCallSites(proc, 4,
                                        sqlenv, routineCatalog, dynamicLineageOptions());
                } catch (RuntimeException ex) {
                        evaluation.note(dynamicEvaluationFailure("call-site binding discovery", ex));
                }
                if (sameFile != null) {
                        bindingSets = sameFile.getBindingSets().size();
                        addBoundVariants(evaluation, proc, sameFile);
                }
                evaluation.bindingsExhaustive = sameFile != null && sameFile.isExhaustive();
                // Cross-file discovery (plan Phase 5): literal EXEC calls in OTHER
                // files of this multi-file analysis. Same-file bindings keep priority;
                // the overall binding-set cap stays at 4.
                if (routineCatalog != null && bindingSets < 4) {
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.CallSiteDiscovery crossFile = null;
                        try {
                                crossFile = gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                                .discoverCrossFileCallSites(proc, routineCatalog, 4 - bindingSets, sqlenv, dynamicLineageOptions());
                        } catch (RuntimeException ex) {
                                evaluation.note(dynamicEvaluationFailure("call-site binding discovery in the other units", ex));
                        }
                        if (crossFile != null) {
                                addBoundVariants(evaluation, proc, crossFile);
                        }
                        evaluation.bindingsExhaustive &= crossFile != null && crossFile.isExhaustive();
                } else if (routineCatalog != null) {
                        // the same file gave the bindings the cap allows: the other units' calls are not looked at
                        evaluation.bindingsExhaustive = false;
                        evaluation.note("calls of the procedure in the other units are not looked at: the same file gives the "
                                        + bindingSets + " bindings evaluated");
                }
                return evaluation;
        }

        /** Notes that the calls of {@code proc} in the analysis are not used, when there are any: presets bind it. */
        private void noteCallsNotUsed(DynamicEvaluation evaluation, TCustomSqlStatement proc) {
                int calls = 0;
                try {
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.CallSiteDiscovery sameFile =
                                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.discoverCallSites(proc, 4);
                        calls += sameFile.getBindingSets().size() + (sameFile.isExhaustive() ? 0 : 1);
                        if (routineCatalog != null) {
                                gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.CallSiteDiscovery crossFile =
                                                gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                                                .discoverCrossFileCallSites(proc, routineCatalog, 4);
                                calls += crossFile.getBindingSets().size() + (crossFile.isExhaustive() ? 0 : 1);
                        }
                } catch (RuntimeException ex) {
                        calls++;
                }
                if (calls > 0) {
                        evaluation.note("calls of the procedure in the analysis are not used: its parameters are preset in the"
                                        + " catalog");
                }
        }

        /** Materializes one group of variants per discovered binding set, each step on its own; keeps the notes. */
        private void addBoundVariants(DynamicEvaluation evaluation, TCustomSqlStatement proc,
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.CallSiteDiscovery discovery) {
                for (String note : discovery.getNotes()) {
                        evaluation.note(note);
                }
                List<Map<String, gudusoft.gsqlparser.dlineage.dynamicsql.SqlValue>> sets = discovery.getBindingSets();
                for (int i = 0; i < sets.size(); i++) {
                        try {
                                evaluation.variants.addAll(gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                                .materializeSiteVariants(proc, option.getVendor(), sets.get(i), dynamicLineageOptions(),
                                                                i < discovery.getBindingSources().size() ? discovery.getBindingSources().get(i) : null));
                        } catch (RuntimeException ex) {
                                evaluation.note(dynamicEvaluationFailure("dynamic SQL evaluation with the call-site binding at "
                                                + discovery.getSources().get(i) + " " + sets.get(i), ex));
                        }
                }
        }

        /** The dynamic SQL evaluation's options: the defaults, with what this analysis's {@link Option} sets. */
        private gudusoft.gsqlparser.dlineage.dynamicsql.DynamicLineageOptions dynamicLineageOptions() {
                return gudusoft.gsqlparser.dlineage.dynamicsql.DynamicLineageOptions.createDefault()
                                .setCaseSensitiveCompare(option.isDynamicSqlCaseSensitiveCompare());
        }

        private static String dynamicEvaluationFailure(String step, RuntimeException ex) {
                return step + " failed: " + ex.getClass().getName()
                                + (ex.getMessage() == null ? "" : ": " + ex.getMessage());
        }

        /**
         * A site's diagnostic with the notes of its procedure's dynamic-SQL evaluation appended. Only the sites of the
         * procedure itself take them, not those inside SQL a dynamic site runs. The evaluation is built here when no
         * site has needed it yet, so every site of the procedure gets the same notes whatever the order they are
         * recorded in (a literal EXEC never needs it otherwise).
         */
        private String withDynamicEvaluationNotes(String diagnostic) {
                if (dynamicFoldDepth != 0 || option == null || option.getVendor() != EDbVendor.dbvmssql) {
                        return diagnostic;
                }
                TCustomSqlStatement proc = enclosingStoredProcedure();
                DynamicEvaluation evaluation = proc == null ? null : dynamicEvaluationOf(proc);
                if (evaluation == null || evaluation.notes.isEmpty()) {
                        return diagnostic;
                }
                StringBuilder sb = new StringBuilder(diagnostic == null ? "" : diagnostic);
                for (String note : evaluation.notes) {
                        if (sb.indexOf(note) >= 0) {
                                continue;
                        }
                        if (sb.length() > 0) {
                                sb.append("; ");
                        }
                        sb.append(note);
                }
                return sb.toString();
        }

        /** All distinct usable materializations for one EXEC, in stable variant order. */
        private List<gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite> evaluatedDynamicSqlVariantsFor(
                        TCustomSqlStatement execStmt, boolean concreteOnly) {
                // one variant per text; when two bindings give the same text, its diagnostic names both
                Map<String, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite> distinct =
                                new LinkedHashMap<String, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>();
                for (gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite candidate : selectVariants(execStmt)) {
                        if (candidate.sqlText == null || (concreteOnly && candidate.partial) || isWholeTextHole(candidate)) {
                                continue;
                        }
                        String key = candidate.partial + "\u0000" + candidate.sqlText;
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite kept = distinct.get(key);
                        // the same text from another binding: one variant with the weaker evidence of the two, naming both
                        distinct.put(key, kept == null ? candidate : kept.mergedWith(candidate));
                }
                return new ArrayList<gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>(distinct.values());
        }

        /**
         * Positions of what is analyzed inside dynamic SQL are the source's (Mantis 4851): each token of the parsed
         * {@code inner} text takes the line and column of the character it starts on, in the string literal of the
         * source that character was read from ({@link gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment#pieces}). A
         * token that starts in a part read from no literal (a variable's value, a transform's output) takes the place
         * that part is spliced in, just past the closing quote of the literal before it, else the position of
         * {@code exec}, the statement that runs the SQL; so a node's span never runs backwards. Nothing changes when the
         * fragments do not spell the text. A string assembled out of source order, and dynamic SQL inside dynamic SQL,
         * take the EXEC's position as a whole. The token's offset into the analyzed text is kept: hole marking reads it.
         */
        private void remapDynamicPositions(TGSqlParser inner,
                        List<gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment> fragments, TCustomSqlStatement exec) {
                if (inner == null || inner.sourcetokenlist == null || inner.sqltext == null || fragments == null
                                || fragments.isEmpty() || exec == null || exec.getStartToken() == null) {
                        return;
                }
                // Dynamic SQL inside dynamic SQL: its literal's tokens already carry positions in the outer string, whose
                // quotes are doubled once more, so a character count from them would drift; it takes the EXEC's position.
                boolean exact = dynamicFoldDepth == 0;
                int n = inner.sqltext.length();
                long[] lines = new long[n];
                long[] columns = new long[n];
                // past the closing quote of a piece that ends before index i: where an unread part after it is spliced in
                long[] spliceLines = new long[n + 1];
                long[] spliceColumns = new long[n + 1];
                int base = 0;
                for (gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment f : fragments) {
                        if (f.isLiteral()) {
                                for (gudusoft.gsqlparser.dlineage.dynamicsql.SqlFragment.SourcePiece piece : f.pieces) {
                                        long[] end = piece.fill(lines, columns, base);
                                        int after = base + piece.textStart + piece.length;
                                        if (after >= 0 && after <= n) {
                                                spliceLines[after] = end[0];
                                                spliceColumns[after] = end[1];
                                        }
                                }
                        }
                        base += f.text.length();
                }
                if (base != n) {
                        return;
                }
                long execLine = exec.getStartToken().lineNo;
                long execColumn = exec.getStartToken().columnNo;
                long carryLine = execLine;
                long carryColumn = execColumn;
                for (int i = 0; i < n; i++) {
                        if (spliceLines[i] > 0) {
                                carryLine = spliceLines[i];
                                carryColumn = spliceColumns[i];
                        }
                        if (lines[i] <= 0) {
                                lines[i] = carryLine;
                                columns[i] = carryColumn;
                        }
                        // a string assembled out of source order (a part prepended, one literal used twice) has no span that
                        // runs forwards through the source: the whole text takes the EXEC's position
                        if (i > 0 && (lines[i] < lines[i - 1] || (lines[i] == lines[i - 1] && columns[i] < columns[i - 1]))) {
                                exact = false;
                        }
                }
                if (!exact) {
                        java.util.Arrays.fill(lines, execLine);
                        java.util.Arrays.fill(columns, execColumn);
                }
                for (int i = 0; i < inner.sourcetokenlist.size(); i++) {
                        TSourceToken token = inner.sourcetokenlist.get(i);
                        int at = (int) token.offset;
                        if (at >= 0 && at < n) {
                                token.lineNo = lines[at];
                                token.columnNo = columns[at];
                        }
                }
        }

        private boolean analyzeEvaluatedDynamicSqlVariants(TCustomSqlStatement stmt,
                        DynamicSqlSite.Kind kind, boolean concreteOnly) {
                boolean handled = false;
                for (gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site :
                                evaluatedDynamicSqlVariantsFor(stmt, concreteOnly)) {
                        handled |= analyzeEvaluatedDynamicSql(stmt, kind, site);
                }
                return handled;
        }

        /**
         * Analyze the materialized text of a dynamic site through the ordinary inner-SQL
         * path and record a truthful site status. Returns true when the site was handled
         * (recorded) here; false when the text was unusable and the caller should record
         * its own UNRESOLVED diagnostic.
         */
        private boolean analyzeEvaluatedDynamicSql(TCustomSqlStatement stmt, DynamicSqlSite.Kind kind,
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite site) {
                if (site == null || site.sqlText == null) {
                        return false;
                }
                DynamicSqlTrustMode trustMode = option.getDynamicSqlTrustMode();
                boolean provenanceIncomplete = site.provenanceIncomplete;
                DynamicHoleEvidence holeEvidence = dynamicHoleEvidence(site);
                int holeCount = holeEvidence.count;
                boolean holeCountExact = holeEvidence.exact;
                Set<Relationship> shadowBefore = provenanceIncomplete && trustMode == DynamicSqlTrustMode.SHADOW
                                ? snapshotDynamicRelationships() : null;
                int relsBeforeDynamic = modelManager.getRelations().length;
                int dynamicSitesBefore = dynamicSqlSites.size();
                // This is the ONE place partially-materialized text reaches the ordinary inner-SQL
                // path, and the site carries exact provenance — so the endpoints it introduces can be
                // marked from real HOLE fragments rather than from a name heuristic.
                Set<Table> templateTablesBefore = snapshotTemplateCandidateTables(
                                site.partial || provenanceIncomplete);
                TGSqlParser sqlparser = createSqlParser(option.getVendor());
                sqlparser.sqltext = site.sqlText;
                boolean foldStatementsAnalyzed = false;
                int result = parseWithCommentBindings(sqlparser);
                if (result == 0) {
                        remapDynamicPositions(sqlparser, site.fragments, stmt);
                }
                if (result == 0 && sqlparser.sqlstatements != null) {
                        foldStatementsAnalyzed = true;
                        List<TConstant> templatedFiles = templateTablesBefore == null
                                        ? Collections.<TConstant>emptyList() : noteTemplatedLoadFiles(site, sqlparser);
                        dynamicFoldDepth++;
                        try {
                                for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                        analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                }
                        } finally {
                                dynamicFoldDepth--;
                                forgetTemplatedLoadFiles(templatedFiles);
                        }
                }
                if (foldStatementsAnalyzed) {
                        markDynamicTemplateEndpoints(templateTablesBefore, site, sqlparser);
                }
                int[] dynCounts = classifyDynamicSiteLineage(relsBeforeDynamic, site.partial);
                int unprovenCount = countNewDynamicRelationships(shadowBefore);
                if (result != 0) {
                        // Evaluated text always derives from variables, and the evaluation is
                        // flow-insensitive — the variable may hold a different value at runtime.
                        // A parse failure on it is therefore data-driven UNRESOLVED, never
                        // PARSE_ERROR (which stays reserved for compile-time literal arguments,
                        // matching the fold path's contract).
                        String reason = site.partial ? "partially evaluated dynamic SQL failed to parse; unresolved parts remain"
                                        : "evaluated dynamic SQL failed to parse; value is flow-insensitive";
                        if (provenanceIncomplete && trustMode == DynamicSqlTrustMode.SHADOW) {
                                reason = dynamicTrustReason(reason + "; SHADOW retained legacy publication behavior",
                                                unprovenCount, holeCount, holeCountExact);
                        }
                        recordDynamicSqlSite(stmt, kind, DynamicSqlSite.Status.UNRESOLVED, reason,
                                        dynCounts[0], dynCounts[1], unprovenCount,
                                        holeCount, holeCountExact, trustMode,
                                        relsBeforeDynamic, dynamicSitesBefore, null, site.diagnostic,
                                        holeEvidence.fragments, holeEvidence.materializedText, site.executionCertain);
                        return true;
                }
                boolean usable = dynCounts[2] == 0
                                && (dynCounts[0] > 0 || (dynCounts[1] == 0 && dynCounts[3] > 0));
                // a statement that moves no data (DELETE, TRUNCATE, DROP), its text known in full: resolved, and rightly
                // without lineage (Mantis 4962); any other statement without lineage may be one the analysis misses
                if (!usable && !site.partial && !provenanceIncomplete && holeCount == 0 && dynCounts[0] == 0
                                && dynCounts[1] == 0 && dynCounts[2] == 0 && dynCounts[3] == 0
                                && movesNoData(sqlparser.sqlstatements)) {
                        usable = true;
                }
                DynamicSqlSite.Status status = usable ? DynamicSqlSite.Status.RESOLVED
                                : DynamicSqlSite.Status.UNRESOLVED;
                String reason = usable ? null
                                : (dynCounts[2] != 0
                                                ? "dynamic SQL references a runtime-built object name; lineage source is a placeholder"
                                                : "evaluated dynamic SQL produced no resolved lineage");
                if (provenanceIncomplete && trustMode == DynamicSqlTrustMode.SHADOW) {
                        status = unprovenCount > 0 ? DynamicSqlSite.Status.PARTIAL
                                        : DynamicSqlSite.Status.UNRESOLVED;
                        reason = dynamicTrustReason("SHADOW retained legacy publication behavior",
                                        unprovenCount, holeCount, holeCountExact);
                }
                recordDynamicSqlSite(stmt, kind,
                                status, reason, dynCounts[0], dynCounts[1], unprovenCount,
                                holeCount, holeCountExact, trustMode,
                                relsBeforeDynamic, dynamicSitesBefore, null, site.diagnostic,
                                holeEvidence.fragments, holeEvidence.materializedText, site.executionCertain);
                if (foldStatementsAnalyzed && !dynamicSqlSites.isEmpty()) {
                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                dynamicInnerSiteIndexes.put(sqlparser.sqlstatements.get(i), dynamicSqlSites.size() - 1);
                        }
                }
                return true;
        }

        /**
         * Whether every statement of a dynamic SQL text only removes rows or objects and moves no data: DELETE that reads
         * no table but its target (no WHERE, no OUTPUT, no join, no second table), TRUNCATE TABLE, DROP TABLE.
         */
        private static boolean movesNoData(TStatementList statements) {
                if (statements == null || statements.size() == 0) {
                        return false;
                }
                for (int i = 0; i < statements.size(); i++) {
                        TCustomSqlStatement stmt = statements.get(i);
                        if (stmt instanceof TDeleteSqlStatement) {
                                TDeleteSqlStatement delete = (TDeleteSqlStatement) stmt;
                                if (delete.getOutputClause() != null || delete.getWhereClause() != null
                                                || (delete.joins != null && delete.joins.size() > 1)
                                                || (delete.tables != null && delete.tables.size() > 1)) {
                                        return false;
                                }
                                // DELETE t FROM dbo.t t JOIN dbo.u u ON ...: one join entry whose items read another table
                                for (int j = 0; delete.joins != null && j < delete.joins.size(); j++) {
                                        if (delete.joins.getJoin(j).getJoinItems() != null
                                                        && delete.joins.getJoin(j).getJoinItems().size() > 0) {
                                                return false;
                                        }
                                }
                        } else if (!(stmt instanceof TTruncateStatement) && !(stmt instanceof TDropTableSqlStatement)) {
                                return false;
                        }
                }
                return true;
        }

        /**
         * Trigger correlation names (:NEW / :OLD and REFERENCING aliases) denote rows of the
         * trigger's ON table. Bind them so name-based lookups from body statements (e.g. the
         * assignment target in ":alias.col := expr") resolve to the base table. Only
         * ':'-prefixed and trigger-scoped keys are registered - bare alias names could collide
         * with real tables elsewhere in the file.
         */
        private void bindTriggerCorrelationNames(TPlsqlCreateTrigger trigger, Table sourceTable) {
                List<String> correlationNames = new ArrayList<String>();
                correlationNames.add("NEW");
                correlationNames.add("OLD");
                if (trigger.getTriggeringClause() != null
                                && trigger.getTriggeringClause().getReferencingClause() != null
                                && trigger.getTriggeringClause().getReferencingClause().getReferencingItems() != null) {
                        for (TTriggerReferencingItem item : trigger.getTriggeringClause().getReferencingClause()
                                        .getReferencingItems()) {
                                if (item.getCorrelationName() != null) {
                                        correlationNames.add(item.getCorrelationName().toString());
                                }
                        }
                }
                Object bodyScope = trigger.getStatements() != null && trigger.getStatements().size() > 0
                                ? LocalScopes.scopeOf(modelManager, trigger.getStatements().get(0)) : null;
                for (String correlationName : correlationNames) {
                        // By name as written: at top level (:NEW in a WHEN clause), and in the trigger body's scope.
                        modelManager.publishLocalSymbol(LocalSymbolKey.of(null, correlationName, LocalSymbolKey.Kind.CORRELATION),
                                        sourceTable);
                        if (bodyScope != null) {
                                modelManager.publishLocalSymbol(LocalSymbolKey.of(bodyScope, correlationName,
                                                LocalSymbolKey.Kind.CORRELATION), sourceTable);
                        }
                }
        }

        private void analyzeAssignStmt(TAssignStmt stmt) {
                TExpression left = stmt.getLeft();
                TExpression right = stmt.getExpression();
                TObjectName columnObject = null;
                if (left == null) {
                        columnObject = stmt.getVariableName();
                } else if (left.getExpressionType() == EExpressionType.simple_object_name_t) {
                        columnObject = left.getObjectOperand();
                }
                if (columnObject != null) {
                        TableColumn tableColumn = null;
                        List<TableColumn> recordFillTargets = null;
                        if (columnObject.getDbObjectType() == EDbObjectType.variable || stmt.getVariableName() != null) {
                                Variable tableModel;
                                if (columnObject.toString().indexOf(".") != -1) {
                                        List<String> splits = SQLUtil.parseNames(columnObject.toString());
                                        tableModel = modelFactory.createReferencedVariable(splits.get(splits.size() - 2), true);
                                } else {
                                        tableModel = modelFactory.createReferencedVariable(columnObject);
                                }
                                tableModel.setCreateTable(true);
                                tableModel.setSubType(SubType.record);
                                if (tableModel.getColumns() == null || tableModel.getColumns().isEmpty()) {
                                        tableColumn = modelFactory.createTableColumn(tableModel, columnObject, true);
                                } else if (tableModel.getColumns().size() == 1) {
                                        tableColumn = tableModel.getColumns().get(0);
                                } else {
                                        // Whole-record assignment to a field-expanded record (#695):
                                        // every field is filled by the right-hand side, so the fill
                                        // edge is emitted per field. Binding get(0) instead attached
                                        // the whole assignment to one arbitrary field and left the
                                        // rest with no upstream at all.
                                        tableColumn = tableModel.getColumns().get(0);
                                        recordFillTargets = tableModel.getColumns();
                                }
                        } else {
                                List<String> splits = SQLUtil.parseNames(columnObject.toString());
                                if (splits.size() > 1) {
                                        // The record or trigger correlation the target's qualifier names; else a table of that name.
                                        Table tableModel = modelManager.visibleLocal(splits.get(splits.size() - 2), LocalSymbolKey.Kind.VARIABLE);
                                        if (tableModel == null) {
                                                tableModel = modelManager
                                                                .getTableByName(DlineageUtil.getTableIdentityKey(splits.get(splits.size() - 2)));
                                        }
                                        if (tableModel != null) {
                                                tableColumn = modelFactory.createTableColumn(tableModel, columnObject, true);
                                        }
                                }
                        }

                        if (tableColumn != null && right != null) {
                                columnsInExpr visitor = new columnsInExpr();
                                right.inOrderTraverse(visitor);
                                List<TObjectName> objectNames = visitor.getObjectNames();
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                List<TParseTreeNode> constants = visitor.getConstants();
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                List<TableColumn> bindTargets = recordFillTargets != null ? recordFillTargets
                                                : Arrays.asList(tableColumn);
                                for (TableColumn bindTarget : bindTargets) {
                                        Transform transform = new Transform();
                                        transform.setType(Transform.EXPRESSION);
                                        transform.setCode(right);
                                        bindTarget.setTransform(transform);
                                        if (functions != null && !functions.isEmpty()) {
                                                analyzeFunctionDataFlowRelation(bindTarget, functions, EffectType.function);
                                        }
                                        if (subquerys != null && !subquerys.isEmpty()) {
                                                analyzeSubqueryDataFlowRelation(bindTarget, subquerys, EffectType.select);
                                        }
                                        if (objectNames != null && !objectNames.isEmpty()) {
                                                analyzeDataFlowRelation(bindTarget, objectNames, EffectType.select, functions);
                                        }
                                        if (constants != null && !constants.isEmpty()) {
                                                analyzeConstantDataFlowRelation(bindTarget, constants, EffectType.select, functions);
                                        }
                                }
                        }
                }
        }

        private void analyzeOpenForStmt(TOpenforStmt stmt) {
                if (stmt.getSubquery() == null) {
                        return;
                }

                Variable cursorTempTable = modelFactory.createCursor(stmt);
                cursorTempTable.setVariable(true);
                cursorTempTable.setSubType(SubType.cursor);
                modelManager.bindCursorModel(stmt, cursorTempTable);
                analyzeSelectStmt(stmt.getSubquery());

                TableColumn cursorColumn = null;
                if (cursorTempTable.getColumns() == null || cursorTempTable.getColumns().isEmpty()) {
                        TObjectName starColumn = DlineageUtil.syntheticStarName();
                        cursorColumn = modelFactory.createTableColumn(cursorTempTable, starColumn, true);
                } else {
                        cursorColumn = cursorTempTable.getColumns().get(0);
                }

                ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt.getSubquery());
                if (resultSetModel != null) {
                        for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                dataflowRelation.setEffectType(EffectType.cursor);
                                dataflowRelation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                dataflowRelation.setTarget(new TableColumnRelationshipElement(cursorColumn));
                        }
                }
        }

        private void analyzeCursorDeclStmt(TCursorDeclStmt stmt) {
                if (stmt.getSubquery() == null) {
                        return;
                }

                Variable cursorTempTable = modelFactory.createCursor(stmt);
                cursorTempTable.setVariable(true);
                cursorTempTable.setSubType(SubType.cursor);
                modelManager.bindCursorModel(stmt, cursorTempTable);
                analyzeSelectStmt(stmt.getSubquery());
                
                ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt.getSubquery());
                if(resultSetModel!=null && resultSetModel.isDetermined()) {
                        for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                TObjectName columnName = new TObjectName();
                                columnName.setString(resultColumn.getName());
                                TableColumn cursorColumn = modelFactory.createTableColumn(cursorTempTable, columnName, true);           
                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                dataflowRelation.setEffectType(EffectType.cursor);
                                dataflowRelation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                dataflowRelation.setTarget(new TableColumnRelationshipElement(cursorColumn));
                        }
                }
                else {
                        TableColumn cursorColumn = null;
                        if (cursorTempTable.getColumns() == null || cursorTempTable.getColumns().isEmpty()) {
                                TObjectName starColumn = DlineageUtil.syntheticStarName();
                                cursorColumn = modelFactory.createTableColumn(cursorTempTable, starColumn, true);
                        } else {
                                cursorColumn = cursorTempTable.getColumns().get(0);
                        }
                        if (resultSetModel != null) {
                                for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                        ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                        dataflowRelation.setEffectType(EffectType.cursor);
                                        dataflowRelation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(cursorColumn));
                                }
                        }
                }
                
        }

        private void analyzeDb2Declare(TDb2SqlVariableDeclaration stmt) {
                TDeclareVariableList variables = stmt.getVariables();
                if (variables == null) {
                        return;
                }
                for (int i = 0; i < variables.size(); i++) {
                        TDeclareVariable variable = variables.getDeclareVariable(i);
                        if (variable.getTableTypeDefinitions() != null && variable.getTableTypeDefinitions().size() > 0) {


                                TObjectName tableName = variable.getVariableName();
                                TTableElementList columns = variable.getTableTypeDefinitions();

                                Table tableModel = modelFactory.createTableByName(tableName, true);
                                tableModel.setCreateTable(true);
                                String procedureParent = getProcedureParentName(stmt);
                                if (procedureParent != null) {
                                        tableModel.setParent(procedureParent);
                                }
                                modelManager.bindFunctionResult(procedureParentAliasKey(stmt), tableModel);

                                for (int j = 0; j < columns.size(); j++) {
                                        TTableElement tableElement = columns.getTableElement(j);
                                        TColumnDefinition column = tableElement.getColumnDefinition();
                                        if (column != null && column.getColumnName() != null) {
                                                modelFactory.createTableColumn(tableModel, column.getColumnName(), true);
                                        }
                                }
                        } else if (variable.getVariableName() != null) {
                                Variable cursorVariable = modelFactory.createVariable(variable.getVariableName());
                                cursorVariable.setCreateTable(true);
                                cursorVariable.setSubType(SubType.record);
                                if(variable.getDatatype()!=null && isSimpleDataType(variable.getDatatype())){
                                        TableColumn variableProperty = modelFactory.createTableColumn(cursorVariable,
                                                        variable.getVariableName(), true);
                                }
                                else {
                                        TObjectName variableProperties = DlineageUtil.syntheticStarName();
                                        TableColumn variableProperty = modelFactory.createTableColumn(cursorVariable,
                                                        variableProperties, true);
                                }
                        }
                }
        }

        private void analyzeMssqlDeclare(TMssqlDeclare stmt) {
                if (stmt.getDeclareType() == EDeclareType.variable) {
                        TDeclareVariableList variables = stmt.getVariables();
                        if (variables == null) {
                                return;
                        }
                        for (int i = 0; i < variables.size(); i++) {
                                TDeclareVariable variable = variables.getDeclareVariable(i);
                                if (variable.getTableTypeDefinitions() != null && variable.getTableTypeDefinitions().size() > 0) {


                                        TObjectName tableName = variable.getVariableName();
                                        TTableElementList columns = variable.getTableTypeDefinitions();

                                        Variable tableModel = modelFactory.createVariable(tableName);
                                        tableModel.setVariable(true);
                    tableModel.setCreateTable(true);
                                        String procedureParent = getProcedureParentName(stmt);
                                        if (procedureParent != null) {
                                                tableModel.setParent(procedureParent);
                                        }
                                        modelManager.bindFunctionResult(procedureParentAliasKey(stmt), tableModel);

                                        for (int j = 0; j < columns.size(); j++) {
                                                TTableElement tableElement = columns.getTableElement(j);
                                                TColumnDefinition column = tableElement.getColumnDefinition();
                                                if (column != null && column.getColumnName() != null) {
                                                        modelFactory.createTableColumn(tableModel, column.getColumnName(), true);
                                                }
                                        }
                                } else if (variable.getVariableName() != null) {
                                        Variable cursorVariable = modelFactory.createVariable(variable.getVariableName());
                                        cursorVariable.setCreateTable(true);
                                        cursorVariable.setSubType(SubType.record);
                                        TableColumn variableProperty = null;
                                        if (variable.getDatatype() != null && isSimpleDataType(variable.getDatatype())) {
                                                variableProperty = modelFactory.createTableColumn(cursorVariable, variable.getVariableName(),
                                                                true);
                                        } else {
                                                TObjectName variableProperties = DlineageUtil.syntheticStarName();
                                                variableProperty = modelFactory.createTableColumn(cursorVariable, variableProperties, true);
                                        }
                                        
                                        if (variable.getDefaultValue() != null && variable.getDefaultValue().getSubQuery() != null) {
                                                analyzeSelectStmt(variable.getDefaultValue().getSubQuery());
                                                ResultSet resultSetModel = (ResultSet) modelManager
                                                                .getModel(variable.getDefaultValue().getSubQuery());
                                                if (variableProperty != null && resultSetModel != null) {
                                                        for (ResultColumn column : resultSetModel.getColumns()) {
                                                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                                dataflowRelation.setEffectType(EffectType.select);
                                                                dataflowRelation.addSource(new ResultColumnRelationshipElement(column));
                                                                dataflowRelation.setTarget(new TableColumnRelationshipElement(variableProperty));
                                                        }
                                                }
                                        }
                                }
                        }
                } else if (stmt.getDeclareType() == EDeclareType.cursor) {
                        Variable cursorTempTable = modelFactory.createCursor(stmt);
                        cursorTempTable.setVariable(true);
                        cursorTempTable.setSubType(SubType.cursor);
                        modelManager.bindCursorModel(stmt, cursorTempTable);
                        analyzeSelectStmt(stmt.getSubquery());
                        ResultSet resultSetModel = (ResultSet)modelManager.getModel(stmt.getSubquery());
                        if (resultSetModel != null && resultSetModel.isDetermined()) {
                                for(ResultColumn resultColumn: resultSetModel.getColumns()){
                                        TObjectName starColumn = new TObjectName();
                                        starColumn.setString(resultColumn.getName());
                                        TableColumn cursorColumn = modelFactory.createTableColumn(cursorTempTable, starColumn, true);
                                        DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                        dataflowRelation.setEffectType(EffectType.cursor);
                                        dataflowRelation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                        dataflowRelation.setTarget(new TableColumnRelationshipElement(cursorColumn));
                                }
                        }
                        else {
                                TableColumn cursorColumn = null;
                                if (cursorTempTable.getColumns() == null || cursorTempTable.getColumns().isEmpty()) {
                                        TObjectName starColumn = DlineageUtil.syntheticStarName();
                                        cursorColumn = modelFactory.createTableColumn(cursorTempTable, starColumn, true);
                                        cursorColumn.setShowStar(false);
                                        cursorColumn.setExpandStar(true);
                                } else {
                                        cursorColumn = cursorTempTable.getColumns().get(0);
                                }

                                if (resultSetModel != null) {
                                        for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                                ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                dataflowRelation.setEffectType(EffectType.cursor);
                                                dataflowRelation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                dataflowRelation.setTarget(new TableColumnRelationshipElement(cursorColumn));
                                        }
                                }
                        }
                }
        }


        private boolean analyzeMssqlJsonDeclare(TMssqlDeclare stmt, String jsonName, Table jsonTable) {
                TDeclareVariableList variables = stmt.getVariables();
                if (variables == null) {
                        return false;
                }
                for (int i = 0; i < variables.size(); i++) {
                        TDeclareVariable variable = variables.getDeclareVariable(i);
                        TObjectName variableName = variable.getVariableName();
                        if (DlineageUtil.sameQualifiedName(ESQLDataObjectType.dotTable, variableName.toString(), jsonName)) {
                                if (variable.getDefaultValue() != null) {
                                        Table variableTable = modelFactory.createJsonVariable(variableName);
                                        variableTable.setVariable(true);
                                        variableTable.setSubType(SubType.scalar);
                                        variableTable.setCreateTable(true);
                                        TableColumn property = modelFactory.createVariableProperty(variableTable, variable);

                                        for (int j = 0; j < jsonTable.getColumns().size(); j++) {
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.select);
                                                relation.setTarget(new TableColumnRelationshipElement(jsonTable.getColumns().get(j)));
                                                relation.addSource(new TableColumnRelationshipElement(property));
                                        }
                                }
                                return true;
                        }
                }
                return false;
        }

        /**
         * True when the statement has a BigQuery external table option, {@code OPTIONS (uris = [...])}. Other table
         * options, such as the Databricks {@code USING DELTA}, leave the statement to the {@code LOCATION} path.
         */
        private static boolean hasBigQueryExternalOption(TCreateTableSqlStatement stmt) {
                if (stmt.getTableOptions() == null) {
                        return false;
                }
                for (TCreateTableOption option : stmt.getTableOptions()) {
                        if (option.getCreateTableOptionType() == ECreateTableOption.etoBigQueryExternal) {
                                return true;
                        }
                }
                return false;
        }

        private void analyzeCreateTableStmt(TCreateTableSqlStatement stmt) {
                Table declaring = null;
                try {
                        declaring = analyzeCreateTableStmtDeclaring(stmt);
                } finally {
                        if (declaring != null) {
                                declaring.endFieldDeclaration();
                        }
                }
        }

        /** The table whose nested-field declaration this CREATE TABLE opened, set while the statement is analyzed. */
        private Table fieldDeclaringTable;

        private Table analyzeCreateTableStmtDeclaring(TCreateTableSqlStatement stmt) {
                fieldDeclaringTable = null;
                analyzeCreateTableStmtBody(stmt);
                Table declaring = fieldDeclaringTable;
                fieldDeclaringTable = null;
                return declaring;
        }

        /**
         * Plan rule R10: a CREATE TABLE that declares columns opens the nested-field declaration of its table, ended as
         * {@link #recordStatementOrdinals} paired it. False, and nothing opened, for a CREATE ... IF NOT EXISTS of a table
         * that exists, which declares nothing.
         */
        private boolean openFieldDeclaration(Table tableModel, TTable table) {
                if (fieldDeclaringTable != null || table == null || table.getTableName() == null
                                || !nestedProfile().buildsDeclaredTree()) {
                        return true;
                }
                long created = modelManager.getCurrentStatementOrdinal();
                if (noOpCreates.contains(created)) {
                        return false;
                }
                tableModel.openFieldDeclaration(created, declarationEnd(created));
                fieldDeclaringTable = tableModel;
                return true;
        }

        private void analyzeCreateTableStmtBody(TCreateTableSqlStatement stmt) {
                createTableDeclaredFields.clear();
                if (stmt.getCloneSourceTable() != null) {
                        analyzeCloneTableStmt(stmt);
                        return;
                }

                TTable table = stmt.getTargetTable();

                boolean hasDefinition = false;

                if (stmt.getColumnList() != null && stmt.getColumnList().size() > 0) {
                        hasDefinition = true;
                }

                if (table != null) {
                        Table tableModel = modelFactory.createTableFromCreateDDL(table, hasDefinition || (stmt.getSubQuery() == null && hasDefinition)
                                        || (stmt.getSubQuery()!=null && stmt.getSubQuery().getSetOperatorType() == ESetOperatorType.none && !hasStarItem(stmt.getSubQuery().getResultColumnList())));
                        // Authoritative create-effect classification (parse fact, NOT gated on
                        // isDetermined() like fromDDL below). CTAS when there is a defining query,
                        // plain DDL otherwise. See dlineage-authoritative-endpoint-classification.md.
                        tableModel.setCreatedInSql(true);
                        tableModel.setEndpointIntroduction(stmt.getSubQuery() != null
                                        ? EndpointIntroduction.CTAS : EndpointIntroduction.CREATE_TABLE_DDL);
                        if (stmt.isExternal()) {
                                tableModel.setExternal(true);
                        }

                        if (stmt.getSubQuery() != null) {
                                Process process = modelFactory.createProcess(stmt);
                                tableModel.addProcess(process);
                        }

                        String procedureParent = getProcedureParentName(stmt);
                        if (procedureParent != null) {
                                tableModel.setParent(procedureParent);
                        }

                        if (stmt.isUsingTemplate()) {
                                // Snowflake CREATE TABLE ... USING TEMPLATE <query>: the query only
                                // infers the column definitions (e.g. ARRAY_AGG(OBJECT_CONSTRUCT(*))
                                // over INFER_SCHEMA); it does NOT populate the table. Analyze it so its
                                // own sources (the stage / INFER_SCHEMA) still resolve, but do not
                                // project its result columns onto the target table or emit CTAS-style
                                // data-flow edges that would misrepresent it as data population.
                                if (stmt.getSubQuery() != null) {
                                        analyzeSelectStmt(stmt.getSubQuery());
                                }
                                return;
                        }

                        if (hasDefinition) {
                                if(stmt.getSubQuery()!=null) {
                                        TSelectSqlStatement subquery = stmt.getSubQuery();
                                        analyzeSelectStmt(subquery);
                                        Process process = modelFactory.createProcess(stmt);
                                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt.getSubQuery());
                                        if(resultSetModel.isDetermined()){
                                                tableModel.setFromDDL(true);
                                        }
                                        if (resultSetModel != null) {
                                                int resultSetSize = resultSetModel.getColumns().size();
                                                int stmtColumnSize = stmt.getColumnList().size();
                                                int j = 0;
                                                int tableColumnSize = stmtColumnSize;
                                                if (resultSetModel.isDetermined() && resultSetSize > tableColumnSize) {
                                                        tableColumnSize = resultSetSize;
                                                }
                                                // a set operation with a star of unknown width: each listed column reads, from each select, the
                                                // items that can stand at its position (Mantis 4914)
                                                List<TObjectName> aliases = new ArrayList<TObjectName>();
                                                for (int i = 0; i < stmtColumnSize; i++) {
                                                        if (stmt.getColumnList().getColumn(i).getColumnName() != null) {
                                                                aliases.add(stmt.getColumnList().getColumn(i).getColumnName());
                                                        }
                                                }
                                                List<SelectPositions> setSelects = subquery.isCombinedQuery()
                                                                ? setOperationPositions(subquery, aliases.size(), shorterList(aliases)) : null;
                                                if (setSelects != null) {
                                                        mapViewColumnsByCandidates(tableModel, aliases, setSelects, EffectType.create_table, process);
                                                }
                                                for (int i = 0; setSelects == null && i < tableColumnSize && j < resultSetSize; i++) {
                                                        ResultColumn resultColumn = resultSetModel.getColumns().get(j);
                                                        if (i < stmtColumnSize) {
                                                                TObjectName alias = stmt.getColumnList().getColumn(i).getColumnName();
                                                                List<ResultColumn> structItem = null;
                                                                
                                                                if (!resultSetModel.getColumns().get(j).isStarColumn()) {
                                                                        // a select item that builds a STRUCT is one position, all of its fields (rule R8,
                                                                        // Codex review of phase 3)
                                                                        int width = selectItemWidth(resultSetModel.getColumns(), j);
                                                                        if (width > 1 || structFieldPaths.containsKey(resultColumn)) {
                                                                                structItem = new ArrayList<ResultColumn>(
                                                                                                resultSetModel.getColumns().subList(j, j + width));
                                                                        }
                                                                        j += width;
                                                                } else {
                                                                        if (selectItemsFrom(resultSetModel.getColumns(), j, resultSetSize) == stmtColumnSize - i) {
                                                                                j++;
                                                                        }
                                                                }

                                                                if (alias != null && structItem != null) {
                                                                        TableColumn viewColumn = modelFactory.createTableColumn(tableModel, alias, true);
                                                                        if (viewColumn != null) {
                                                                                feedFromStructItem(viewColumn, structItem, alias, EffectType.create_table, process,
                                                                                                true);
                                                                        }
                                                                } else if (alias != null) {
                                                                        TableColumn viewColumn = modelFactory.createTableColumn(tableModel, alias, true);
                                                                        if (resultColumn != null) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.create_table);
                                                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                                relation.addSource(positionSource(resultColumn));
                                                                                relation.setProcess(process);
                                                                                feedBuiltFieldNodes(viewColumn, resultColumn, EffectType.create_table, process, true);
                                                                        }
                                                                } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                                        TableColumn viewColumn = modelFactory.createTableColumn(tableModel,
                                                                                        (TObjectName) resultColumn.getColumnObject(), true);
                                                                        if (resultColumn != null) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.create_table);
                                                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.setProcess(process);
                                                                        }
                                                                } else if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                                                        TableColumn viewColumn = modelFactory.createTableColumn(tableModel,
                                                                                        ((TResultColumn) resultColumn.getColumnObject()).getFieldAttr(), true);
                                                                        ResultColumn column = (ResultColumn) modelManager
                                                                                        .getModel(resultColumn.getColumnObject());
                                                                        if (column != null && column.hasStarLinkColumn()) {
                                                                                viewColumn.shareStarLinksFrom(column);
                                                                        }
                                                                        if (resultColumn != null) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.create_table);
                                                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.setProcess(process);
                                                                        }
                                                                }
                                                        }
                                                        else if(resultSetModel.isDetermined()){
                                                                TObjectName tableName = new TObjectName();
                                                                tableName.setString(resultColumn.getName());
                                                                TableColumn viewColumn = modelFactory.createTableColumn(tableModel, tableName, true);
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.create_table);
                                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.setProcess(process);
                                                                j++;
                                                        }
                                                }
                                                if (resultSetModel != null && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                        impactRelation.setEffectType(EffectType.create_table);
                                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                        resultSetModel.getRelationRows()));
                                                        impactRelation.setTarget(
                                                                        new RelationRowsRelationshipElement<TableRelationRows>(tableModel.getRelationRows()));
                                                }
                                        }

                                        if (subquery.getResultColumnList() == null && subquery.getValueClause() != null
                                                        && subquery.getValueClause().getValueRows().size() == stmt.getColumnList().size()) {
                                                for (int i = 0; i < stmt.getColumnList().size(); i++) {
                                                        TObjectName alias = stmt.getColumnList().getColumn(i).getColumnName();

                                                        if (alias != null) {
                                                                TableColumn viewColumn = modelFactory.createTableColumn(tableModel, alias, true);

                                                                TExpression expression = subquery.getValueClause().getValueRows().getValueRowItem(i).getExpr();

                                                                columnsInExpr visitor = new columnsInExpr();
                                                                expression.inOrderTraverse(visitor);
                                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                                List<TParseTreeNode> functions = visitor.getFunctions();

                                                                if (functions != null && !functions.isEmpty()) {
                                                                        analyzeFunctionDataFlowRelation(viewColumn, functions, EffectType.select);

                                                                }

                                                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                                                if (subquerys != null && !subquerys.isEmpty()) {
                                                                        analyzeSubqueryDataFlowRelation(viewColumn, subquerys, EffectType.select);
                                                                }

                                                                analyzeDataFlowRelation(viewColumn, objectNames, EffectType.select, functions);
                                                                List<TParseTreeNode> constants = visitor.getConstants();
                                                                analyzeConstantDataFlowRelation(viewColumn, constants, EffectType.select, functions);
                                                        }
                                                }
                                        }
                                        
                                        return;
                                }
                                else {
                                        boolean declares = openFieldDeclaration(tableModel, table);
                                        for (int i = 0; i < stmt.getColumnList().size(); i++) {
                                                TColumnDefinition column = stmt.getColumnList().getColumn(i);
                                                if (modelsNestedFieldsAsColumns() && column.getDatatype() != null
                                                                && column.getDatatype().getTypeOfList() != null
                                                                && column.getDatatype().getTypeOfList().getColumnDefList() != null) {
                                                        for (int j = 0; j < column.getDatatype().getTypeOfList().getColumnDefList().size(); j++) {
                                                                TObjectName columnName = new TObjectName();
                                                                if (column.getDatatype().getDataType() == EDataType.array_t) {
//                                                                      columnName.setString(column.getColumnName().getColumnNameOnly() + ".array."
//                                                                                      + column.getDatatype().getTypeOfList().getColumnDefList().getColumn(j)
//                                                                                                      .getColumnName().getColumnNameOnly());
                                                                        columnName.setString(column.getColumnName().getColumnNameOnly() + "."
                                                                                        + column.getDatatype().getTypeOfList().getColumnDefList().getColumn(j)
                                                                                        .getColumnName().getColumnNameOnly());
                                                                } else {
                                                                        columnName.setString(column.getColumnName().getColumnNameOnly() + "."
                                                                                        + column.getDatatype().getTypeOfList().getColumnDefList().getColumn(j)
                                                                                                        .getColumnName().getColumnNameOnly());
                                                                }
                                                                TableColumn tableColumn = modelFactory.createTableColumn(tableModel, columnName,
                                                                                hasDefinition);
                                                                tableColumn.setStruct(true);
                                                                tableColumn.setColumnIndex(i);
                                                                appendTableColumnToSQLEnv(tableModel, tableColumn);
                                                                
                                                                if(option.getAnalyzeMode() == AnalyzeMode.crud) {
                                                                        CrudRelationship crudRelationship = modelFactory.createCrudRelation();
                                                                        crudRelationship.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        crudRelationship.setEffectType(EffectType.create_table);
                                                                }
                                                        }
                                                        continue;
                                                }
                                                if (modelsNestedFieldsAsColumns() && column.getDatatype() != null
                                                                && column.getDatatype().getColumnDefList() != null) {
                                                        Stack<TColumnDefinition> columnPaths = new Stack<TColumnDefinition>();
                                                        flattenStructColumns(hasDefinition, tableModel, column, columnPaths, i);
                                                        continue;
                                                }
                                                TableColumn tableColumn = modelFactory.createTableColumn(tableModel, column.getColumnName(),
                                                                hasDefinition);
                                                if (tableColumn == null) {
                                                        continue;
                                                }

                                                if(option.getAnalyzeMode() == AnalyzeMode.crud) {
                                                        CrudRelationship crudRelationship = modelFactory.createCrudRelation();
                                                        crudRelationship.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                        crudRelationship.setEffectType(EffectType.create_table);
                                                }

                                                if (nestedProfile().buildsDeclaredTree() && declares) {
                                                        List<TableColumn> declaredFields = new ArrayList<TableColumn>();
                                                        createTableDeclaredFields.put(tableColumn, declaredFields);
                                                        createStructFieldNodes(tableColumn, column.getDatatype(),
                                                                        new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>(),
                                                                        column.getColumnName(), declaredFields);
                                                }

                                                if (column.getDatatype() != null && column.getDatatype().getDataType() == EDataType.variant_t) {
                                                        if (tableColumn != null) {
                                                                tableColumn.setVariant(true);
                                                        }
                                                }
                                                if (column.getDatatype() != null) {
                                                        String dType = column.getDatatype().getDataTypeName();
                                                        if ((!SQLUtil.isEmpty(dType)) && (dType.indexOf("_") > 0)) {
                                                                dType = dType.split("_")[0];
                                                        }
                                                        tableColumn.setDataType(dType);
                                                }

                                                // Inline (column-level) PK / FK constraint FLAGS. The
                                                // table-level pass below (stmt.getTableConstraints())
                                                // never sees inline constraints, so set the flags here.
                                                // Without this, "id INTEGER PRIMARY KEY" or
                                                // "fk INTEGER REFERENCES t (c)" produced no
                                                // isPrimaryKey()/isForeignKey() flag, unlike the
                                                // equivalent table-level CONSTRAINT form.
                                                // EConstraintType.reference is the inline REFERENCES
                                                // form; foreign_key is the (rare) inline FOREIGN KEY.
                                                // Only flags are set here (no model objects allocated)
                                                // so column ids are unchanged; the FK relationship
                                                // edges are emitted in a deferred pass after the column
                                                // loop (see "inline FK relationships" below), matching
                                                // the table-level pass ordering so ids stay stable.
                                                TConstraintList inlineConstraints = column.getConstraints();
                                                if (inlineConstraints != null) {
                                                        for (int c = 0; c < inlineConstraints.size(); c++) {
                                                                EConstraintType inlineType = inlineConstraints.getConstraint(c)
                                                                                .getConstraint_type();
                                                                if (inlineType == EConstraintType.primary_key) {
                                                                        tableColumn.setPrimaryKey(true);
                                                                } else if (inlineType == EConstraintType.foreign_key
                                                                                || inlineType == EConstraintType.reference) {
                                                                        tableColumn.setForeignKey(true);
                                                                }
                                                        }
                                                }

                                                appendTableColumnToSQLEnv(tableModel, tableColumn);
                                        }
                                }
                        }

                        if (stmt.getExternalTableOption("DATA_SOURCE") != null) {
                                String dataSourceName = stmt.getExternalTableOption("DATA_SOURCE");
                                Table dataSource = modelManager.getTableByName(DlineageUtil.getTableIdentityKey(dataSourceName));
                                if (dataSource != null) {
                                        TableColumn dataSourceColumn = dataSource.getColumns().get(0);
                                        for (int i = 0; i < tableModel.getColumns().size(); i++) {
                                                TableColumn column = tableModel.getColumns().get(i);
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setTarget(new TableColumnRelationshipElement(column));
                                                relation.addSource(new TableColumnRelationshipElement(dataSourceColumn));

                                                appendTableColumnToSQLEnv(tableModel, column);
                                        }
                                }
                        }

                        if (stmt.getSubQuery() != null) {

                                analyzeSelectStmt(stmt.getSubQuery());

                                ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt.getSubQuery());
                                if (resultSetModel != null && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.setEffectType(EffectType.create_table);
                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        resultSetModel.getRelationRows()));
                                        impactRelation.setTarget(
                                                        new RelationRowsRelationshipElement<TableRelationRows>(tableModel.getRelationRows()));
                                }
                        }

                        if (stmt.getSubQuery() != null && !stmt.getSubQuery().isCombinedQuery()) {
                                SelectResultSet resultSetModel = (SelectResultSet) modelManager
                                                .getModel(stmt.getSubQuery().getResultColumnList());
                                if(resultSetModel.isDetermined()){
                                        tableModel.setDetermined(true);
                                        tableModel.setFromDDL(true);
                                }
                                for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                        ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                        if (resultSetModel.isDetermined() && resultColumn.isStarColumn()) {
                                                continue;
                                        }

                                        if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                                TResultColumn columnObject = (TResultColumn) resultColumn.getColumnObject();

                                                TAliasClause alias = columnObject.getAliasClause();
                                                if (alias != null && alias.getAliasName() != null) {
                                                        TableColumn tableColumn = null;
                                                        if (!hasDefinition) {
                                                                tableColumn = modelFactory.createTableColumn(tableModel, alias.getAliasName(),
                                                                                !hasDefinition);
                                                        } else {
                                                                tableColumn = tableModel.getColumns().get(i);
                                                        }

                                                        if (!tableColumn.isStarColumn() && tableModel.isDetermined()) {
                                                                appendTableColumnToSQLEnv(tableModel, tableColumn);
                                                        }

                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_table);
                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        Process process = modelFactory.createProcess(stmt);
                                                        relation.setProcess(process);
                                                } else if (columnObject.getFieldAttr() != null || (columnObject.getExpr()!=null && columnObject.getExpr().getExpressionType() == EExpressionType.typecast_t)) {
                                                        TableColumn tableColumn = null;
                                                        TObjectName columnObj = columnObject.getFieldAttr();
                                                        if(columnObj == null) {
                                                                columnObj = columnObject.getExpr().getLeftOperand().getObjectOperand();
                                                        }
                                                        if ((columnObj == null || DlineageUtil.isStarName(columnObj)) && !resultColumn.isStarColumn()) {
                                                                columnObj = new TObjectName();
                                                                columnObj.setString(resultColumn.getName());
                                                        }

                                                        if(columnObj == null){
                                                                logger.info("Can't handle column " + resultColumn.getName());
                                                                continue;
                                                        }

                                                        if (!hasDefinition) {
                                                                tableColumn = modelFactory.createTableColumn(tableModel, columnObj,
                                                                                !hasDefinition);
                                                                if (tableColumn != null) tableColumn.inheritIdentifier(resultColumn);
                                                                if (tableColumn == null) {
                                                                        if (tableModel.getColumns().isEmpty()) {
                                                                                logger.info("Add table " + tableModel.getName() + " column " + columnObj.toString() + " failed");
                                                                        }
                                                                        else if (resultColumn.isStarColumn()) {
                                                                                for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                                                        tableColumn = tableModel.getColumns().get(j);
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.create_table);
                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                        if (tableColumn.isStarColumn()
                                                                                                        && resultColumn.isStarColumn()) {
                                                                                                tableModel.setStarStmt("create_table");
                                                                                        }
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                }
                                                                        }
                                                                        continue;
                                                                }
                                                                if (!tableColumn.isStarColumn() && tableModel.isDetermined()) {
                                                                        appendTableColumnToSQLEnv(tableModel, tableColumn);
                                                                }

                                                                Object model = modelManager
                                                                                .getModel(resultColumn.getColumnObject());
                                                                if (model instanceof ResultColumn) {
                                                                        ResultColumn column = (ResultColumn) model;
                                                                        if (tableColumn.isStarColumn() && column != null
                                                                                        && column.hasStarLinkColumn()) {
                                                                                tableColumn.shareStarLinksFrom(column);
                                                                        }

                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.create_table);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        if (tableColumn.isStarColumn() && resultColumn.isStarColumn()) {
                                                                                tableModel.setStarStmt("create_table");
                                                                        }
                                                                        Process process = modelFactory.createProcess(stmt);
                                                                        relation.setProcess(process);
                                                                }
                                                                else if(model instanceof LinkedHashMap) {
                                                                        String columnName = getColumnNameOnly(resultColumn.getName());
                                                                        LinkedHashMap<String, ResultColumn> resultColumns =  (LinkedHashMap<String, ResultColumn>)model;
                                                                        if (isStarNode(columnObj)) {
                                                                                for (String key : resultColumns.keySet()) {
                                                                                        tableColumn = itemColumnTarget(tableModel, resultColumns.get(key));
                                                                                        DataFlowRelationship relation = modelFactory
                                                                                                        .createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.create_table);
                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.addSource(
                                                                                                        new ResultColumnRelationshipElement(resultColumns.get(key)));
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                }
                                                                        } else if (resultColumns.containsKey(columnName)) {
                                                                                ResultColumn column = resultColumns.get(columnName);
                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel, column);
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.create_table);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(column));
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                        }
                                                                }
                                                        } else {
                                                                if (resultColumn.isStarColumn()) {
                                                                        for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                                                tableColumn = tableModel.getColumns().get(j);
                                                                                ResultColumn column = (ResultColumn) modelManager
                                                                                                .getModel(resultColumn.getColumnObject());
                                                                                if (tableColumn.isStarColumn() && column != null
                                                                                                && column.hasStarLinkColumn()) {
                                                                                        tableColumn.shareStarLinksFrom(column);
                                                                                }

                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.create_table);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                if (tableColumn.isStarColumn()
                                                                                                && resultColumn.isStarColumn()) {
                                                                                        tableModel.setStarStmt("create_table");
                                                                                        ;
                                                                                }
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                        }
                                                                } else {
                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                        Object model = modelManager
                                                                                        .getModel(resultColumn.getColumnObject());
                                                                        String columnName = getColumnNameOnly(resultColumn.getName());
                                                                        if(model instanceof LinkedHashMap) {
                                                                                LinkedHashMap<String, ResultColumn> resultColumns =  (LinkedHashMap<String, ResultColumn>)model;
                                                                                if (resultColumns.size() == tableModel.getColumns().size()) {
                                                                                        int j = 0;
                                                                                        for (String key : resultColumns.keySet()) {
                                                                                                if (j == i) {
                                                                                                        ResultColumn column = resultColumns.get(key);
                                                                                                        DataFlowRelationship relation = modelFactory
                                                                                                                        .createDataFlowRelation();
                                                                                                        relation.setEffectType(EffectType.create_table);
                                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                                        relation.addSource(new ResultColumnRelationshipElement(column));
                                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                                        relation.setProcess(process);
                                                                                                }
                                                                                                j++;
                                                                                        }
                                                                                } else if (resultColumns.containsKey(columnName)) {
                                                                                        ResultColumn column = resultColumns.get(columnName);
                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel, column);
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.create_table);
                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(column));
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                } else {
                                                                                        throw new UnsupportedOperationException("Can't handle this star case.");
                                                                                }
                                                                        }
                                                                        else if (model instanceof ResultColumn) {
                                                                                ResultColumn column = (ResultColumn) modelManager
                                                                                                .getModel(resultColumn.getColumnObject());
                                                                                if (tableColumn.isStarColumn() && column != null
                                                                                                && column.hasStarLinkColumn()) {
                                                                                        tableColumn.shareStarLinksFrom(column);
                                                                                }

                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.create_table);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                if (tableColumn.isStarColumn()
                                                                                                && resultColumn.isStarColumn()) {
                                                                                        tableModel.setStarStmt("create_table");
                                                                                }
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                        }
                                                                }
                                                        }
                                                } else {
                                                        TableColumn tableColumn = null;
                                                        if (!hasDefinition) {
                                                                TObjectName columnName = new TObjectName();
                                                                columnName.setString(resultColumn.getColumnObject().toString());
                                                                tableColumn = modelFactory.createTableColumn(tableModel, columnName, !hasDefinition);
                                                                if(tableColumn == null){
                                                                        continue;
                                                                }
                                                        } else {
                                                                tableColumn = tableModel.getColumns().get(i);
                                                        }
                                                        ResultColumn column = (ResultColumn) modelManager.getModel(resultColumn.getColumnObject());
                                                        if (column != null && column.hasStarLinkColumn()) {
                                                                tableColumn.shareStarLinksFrom(column);
                                                        }

                                                        if (!tableColumn.isStarColumn() && tableModel.isDetermined()) {
                                                                appendTableColumnToSQLEnv(tableModel, tableColumn);
                                                        }

                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_table);
                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        Process process = modelFactory.createProcess(stmt);
                                                        relation.setProcess(process);
                                                }
                                        } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                StructFieldPath structField = hasDefinition ? null : structFieldPaths.get(resultColumn);
                                                if (structField != null && structField.alias != null) {
                                                        // STRUCT tree: a field of a STRUCT or ROW the query builds, payload.a of
                                                        // named_struct('a', x) AS payload, is the field node payload.a below the table's column
                                                        // payload, as for a view (Mantis 4847, 4834); a nested one is payload.a.b (Mantis 4892)
                                                        TObjectName alias = structField.alias;
                                                        boolean first = modelManager.getModel(new Pair<Table, TObjectName>(tableModel, alias)) == null;
                                                        TableColumn declared = modelFactory.createTableColumn(tableModel, alias, true);
                                                        TableColumn node = declared == null ? null
                                                                        : modelFactory.createFieldPath(declared, structField.segments(), alias);
                                                        if (node != null) {
                                                                if (tableModel.isDetermined() && first) {
                                                                        appendTableColumnToSQLEnv(tableModel, declared);
                                                                }
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.create_table);
                                                                relation.setTarget(new TableColumnRelationshipElement(node));
                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                Process process = modelFactory.createProcess(stmt);
                                                                relation.setProcess(process);
                                                                continue;
                                                        }
                                                }
                                                TableColumn tableColumn = null;
                                                if (!hasDefinition) {
                                                        tableColumn = modelFactory.createTableColumn(tableModel,
                                                                        (TObjectName) resultColumn.getColumnObject(), !hasDefinition);
                                                } else {
                                                        tableColumn = tableModel.getColumns().get(i);
                                                }

                                                if (!tableColumn.isStarColumn() && tableModel.isDetermined()) {
                                                        appendTableColumnToSQLEnv(tableModel, tableColumn);
                                                }

                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.create_table);
                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                Process process = modelFactory.createProcess(stmt);
                                                relation.setProcess(process);
                                        }
                                }
                        } else if (stmt.getSubQuery() != null) {
                                SelectSetResultSet resultSetModel = (SelectSetResultSet) modelManager.getModel(stmt.getSubQuery());
                                if(resultSetModel.isDetermined()){
                                        tableModel.setDetermined(true);
                                        tableModel.setFromDDL(true);
                                }
                                for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                        ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                        if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                                TResultColumn columnObject = (TResultColumn) resultColumn.getColumnObject();

                                                TAliasClause alias = columnObject.getAliasClause();
                                                if (alias != null && alias.getAliasName() != null) {
                                                        TableColumn tableColumn = null;
                                                        if (!hasDefinition) {
                                                                tableColumn = modelFactory.createTableColumn(tableModel, alias.getAliasName(),
                                                                                !hasDefinition);
                                                                if (tableColumn == null) {
                                                                        continue;
                                                                }
                                                        } else {
                                                                tableColumn = tableModel.getColumns().get(i);
                                                        }

                                                        if (!tableColumn.isStarColumn() && tableModel.isDetermined()) {
                                                                appendTableColumnToSQLEnv(tableModel, tableColumn);
                                                        }

                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_table);
                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        Process process = modelFactory.createProcess(stmt);
                                                        relation.setProcess(process);
                                                        feedBuiltFieldNodes(tableColumn, resultColumn, EffectType.create_table, process, false);
                                                } else if (columnObject.getFieldAttr() != null || (columnObject.getExpr()!=null && columnObject.getExpr().getExpressionType() == EExpressionType.typecast_t)) {
                                                        TableColumn tableColumn = null;
                                                        TObjectName columnObj = columnObject.getFieldAttr();
                                                        if(columnObj == null) {
                                                                columnObj = columnObject.getExpr().getLeftOperand().getObjectOperand();
                                                        }
                                                        if (!hasDefinition) {
                                                                tableColumn = modelFactory.createTableColumn(tableModel, columnObj,
                                                                                !hasDefinition);
                                                                if (tableColumn == null) {
                                                                        continue;
                                                                }
                                                        } else {
                                                                tableColumn = tableModel.getColumns().get(i);
                                                        }
                                                        ResultColumn column = (ResultColumn) modelManager.getModel(resultColumn.getColumnObject());
                                                        if (column != null && column.hasStarLinkColumn()) {
                                                                tableColumn.shareStarLinksFrom(column);
                                                        }

                                                        if (!tableColumn.isStarColumn() && tableModel.isDetermined()) {
                                                                appendTableColumnToSQLEnv(tableModel, tableColumn);
                                                        }

                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_table);
                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        Process process = modelFactory.createProcess(stmt);
                                                        relation.setProcess(process);
                                                        feedBuiltFieldNodes(tableColumn, resultColumn, EffectType.create_table, process, false);
                                                } else {
                                                        ErrorInfo errorInfo = new ErrorInfo();
                                                        errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                                                        errorInfo.setErrorMessage("Can't handle the table column " + columnObject.toString());
                                                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(
                                                                        columnObject.getStartToken().lineNo, columnObject.getStartToken().columnNo,
                                                                        ModelBindingManager.getGlobalHash()));
                                                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(columnObject.getEndToken().lineNo,
                                                                        columnObject.getEndToken().columnNo + columnObject.getEndToken().getAstext().length(),
                                                                        ModelBindingManager.getGlobalHash()));
                                                        errorInfos.add(errorInfo);
                                                        continue;
                                                }
                                        } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                TableColumn tableColumn = null;
                                                if (!hasDefinition) {
                                                        tableColumn = modelFactory.createTableColumn(tableModel,
                                                                        (TObjectName) resultColumn.getColumnObject(), !hasDefinition);
                                                } else {
                                                        tableColumn = tableModel.getColumns().get(i);
                                                }

                                                if (!tableColumn.isStarColumn() && tableModel.isDetermined()) {
                                                        appendTableColumnToSQLEnv(tableModel, tableColumn);
                                                }

                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.create_table);
                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                Process process = modelFactory.createProcess(stmt);
                                                relation.setProcess(process);
                                                feedBuiltFieldNodes(tableColumn, resultColumn, EffectType.create_table, process, false);
                                        }
                                }
                        } else if (stmt.getLikeTableName() != null) {
                                Table likeTableModel = modelFactory.createTableByName(stmt.getLikeTableName());

                                if(likeTableModel.isCreateTable()){
                                        for(TableColumn column: likeTableModel.getColumns()){
                                                TObjectName tableColumn = new TObjectName();
                                                tableColumn.setString(column.getName());
                                                TableColumn createTableColumn = modelFactory.createTableColumn(tableModel, tableColumn, true);
                                                createTableColumn.setPrimaryKey(column.getPrimaryKey());
                                                createTableColumn.setForeignKey(column.getForeignKey());
                                                createTableColumn.setIndexKey(column.getIndexKey());
                                                createTableColumn.setUnqiueKey(column.getUnqiueKey());
                                                createTableColumn.setDataType(column.getDataType());
                                        }
                                        tableModel.setCreateTable(true);
                                }

//                              Process process = modelFactory.createProcess(stmt);
//                              process.setType("Like Table");
//                              tableModel.addProcess(process);
//
//
//                              DataFlowRelationship relation = modelFactory.createDataFlowRelation();
//                              relation.setEffectType(EffectType.like_table);
//                              relation.setTarget(
//                                              new RelationRowsRelationshipElement<TableRelationRows>(tableModel.getRelationRows()));
//                              relation.addSource(
//                                              new RelationRowsRelationshipElement<TableRelationRows>(likeTableModel.getRelationRows()));
//                              relation.setProcess(process);
                        }

                        if (stmt.getStageLocation() != null && stmt.getStageLocation().getStageName() != null) {
                                // The stage the table reads, by its name as written: found and compared by identity.
                                tableModel.setLocation(stmt.getStageLocation().getStageName().toString());
                                Process process = modelFactory.createProcess(stmt);
                                process.setType("Create External Table");
                                tableModel.addProcess(process);
                                Table stage = modelManager.getTableByName(DlineageUtil.getTableIdentityKey(tableModel.getLocation()));
                                if (stage == null) {
                                        stage = modelManager.getTableByName(
                                                        DlineageUtil.getTableIdentityKey(stmt.getStageLocation().toString().replaceFirst("@", "")));
                                }
                                if (stage == null) {
                                        stage = modelFactory.createTableByName(stmt.getStageLocation().toString().replaceFirst("@", ""),
                                                        false);
                                        stage.setCreateTable(false);
                                        stage.setStage(true);
                                        if (stmt.getStageLocation().getPath() != null) {
                                                stage.setLocation(stmt.getStageLocation().getPath().toString());
                                                TObjectName location = new TObjectName();
                                                location.setString(stmt.getStageLocation().getPath().toString());
                                                modelFactory.createStageLocation(stage, location);
                                        } else if (stmt.getRegex_pattern() != null) {
                                                stage.setLocation(stmt.getRegex_pattern());
                                                TObjectName location = new TObjectName();
                                                location.setString(stmt.getRegex_pattern());
                                                modelFactory.createStageLocation(stage, location);
                                        } else {
                                                stage.setLocation("unknownPath");
                                                TObjectName location = new TObjectName();
                                                location.setString("unknownPath");
                                                modelFactory.createStageLocation(stage, location);
                                        }
                                }
                                if (stage != null && !stage.getColumns().isEmpty()) {
                                        if (!tableModel.getColumns().isEmpty()) {
                                                for (int i = 0; i < tableModel.getColumns().size(); i++) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.addSource(new TableColumnRelationshipElement(stage.getColumns().get(0)));
                                                        relation.setTarget(new TableColumnRelationshipElement(tableModel.getColumns().get(i)));
                                                        relation.setProcess(process);
                                                }
                                        } else {
                                                TObjectName starColumn = DlineageUtil.syntheticStarName();
                                                TableColumn tableColumn = modelFactory.createTableColumn(tableModel, starColumn, true);
                                                tableColumn.setExpandStar(false);
                                                tableColumn.setShowStar(true);
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.addSource(new TableColumnRelationshipElement(stage.getColumns().get(0)));
                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                relation.setProcess(process);
                                        }
                                }
                        } else if (hasBigQueryExternalOption(stmt)) {
                                for (int i = 0; i < stmt.getTableOptions().size(); i++) {
                                        TCreateTableOption createTableOption = stmt.getTableOptions().get(i);
                                        if (createTableOption.getCreateTableOptionType() != ECreateTableOption.etoBigQueryExternal)
                                                continue;
                                        List<String> uris = createTableOption.getUris();
                                        if (uris == null || uris.isEmpty())
                                                continue;
                                        Process process = modelFactory.createProcess(stmt);
                                        process.setType("Create External Table");
                                        tableModel.addProcess(process);
                                        if (tableModel.getColumns().isEmpty()) {
                                                TObjectName starColumn = DlineageUtil.syntheticStarName();
                                                TableColumn tableColumn = modelFactory.createTableColumn(tableModel, starColumn, true);
                                                tableColumn.setExpandStar(false);
                                                tableColumn.setShowStar(true);
                                        }
                                        for (String uri : uris) {
                                                Table uriFile = modelFactory.createTableByName(uri, true);
                                                uriFile.setPath(true);
                                                uriFile.setFileFormat(createTableOption.getFormat());
                                                for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        if (stmt.getColumnList() != null) {
                                                                // The file's field for the table's column; the table's star stays a star.
                                                                TableColumn tableColumn = tableModel.getColumns().get(j);
                                                                TObjectName fileUri = tableColumn.isStarColumn() ? DlineageUtil.syntheticStarName()
                                                                                : new TObjectName();
                                                                if (!tableColumn.isStarColumn()) {
                                                                        fileUri.setString(tableColumn.getColumnObject().toString());
                                                                }
                                                                TableColumn fileUriColumn = modelFactory.createFileUri(uriFile, fileUri);
                                                                relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                                        } else {
                                                                TObjectName fileUri = DlineageUtil.syntheticStarName();
                                                                TableColumn fileUriColumn = modelFactory.createFileUri(uriFile, fileUri);
                                                                relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                                        }
                                                        relation.setTarget(new TableColumnRelationshipElement(tableModel.getColumns().get(j)));
                                                        relation.setProcess(process);
                                                }
                                                if (tableModel.getColumns().isEmpty()) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        TObjectName fileUri = DlineageUtil.syntheticStarName();
                                                        TableColumn fileUriColumn = modelFactory.createFileUri(uriFile, fileUri);
                                                        relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                                        relation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                        tableModel.getRelationRows()));
                                                        relation.setProcess(process);
                                                }
                                        }
                                }
                        } else if (stmt.getSubQuery() == null && stmt.getTableLocation() != null) {
                                Process process = modelFactory.createProcess(stmt);
                                process.setType("Create External Table");
                                tableModel.addProcess(process);
                                if (tableModel.getColumns().isEmpty()) {
                                        // No column list, as in CREATE TABLE t USING DELTA LOCATION '...': the files give the table's star.
                                        TObjectName starColumn = DlineageUtil.syntheticStarName();
                                        TableColumn tableColumn = modelFactory.createTableColumn(tableModel, starColumn, true);
                                        tableColumn.setExpandStar(false);
                                        tableColumn.setShowStar(true);
                                }
                                Table uriFile = modelFactory.createTableByName(stmt.getTableLocation(), true);
                                uriFile.setPath(true);
                                for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        if (stmt.getColumnList() != null) {
                                                // The file's field for the table's column; the table's star stays a star.
                                                TableColumn tableColumn = tableModel.getColumns().get(j);
                                                TObjectName fileUri = tableColumn.isStarColumn() ? DlineageUtil.syntheticStarName()
                                                                : new TObjectName();
                                                if (!tableColumn.isStarColumn()) {
                                                        fileUri.setString(tableColumn.getColumnObject().toString());
                                                }
                                                TableColumn fileUriColumn = modelFactory.createFileUri(uriFile, fileUri);
                                                relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                                linkDeclaredFieldsToFile(tableColumn, fileUriColumn, process);
                                        } else {
                                                TObjectName fileUri = DlineageUtil.syntheticStarName();
                                                TableColumn fileUriColumn = modelFactory.createFileUri(uriFile, fileUri);
                                                relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                        }
                                        relation.setTarget(new TableColumnRelationshipElement(tableModel.getColumns().get(j)));
                                        relation.setProcess(process);
                                }
                        }

                        // Inline (column-level) FK relationships. Emitted here, after the
                        // column loop, rather than inline in it, so the referenced-column /
                        // relation / process model objects allocate their ids AFTER all
                        // column ids (matching the table-level pass below) and column ids
                        // stay stable. Mirrors the table-level FK emission: source =
                        // referenced column, target = this FK column, effect = foreign_key,
                        // plus the optional ER relationship. EConstraintType.reference is
                        // the inline REFERENCES form; foreign_key the inline FOREIGN KEY.
                        if (stmt.getColumnList() != null) {
                                for (int i = 0; i < stmt.getColumnList().size(); i++) {
                                        TColumnDefinition fkColumnDef = stmt.getColumnList().getColumn(i);
                                        TConstraintList fkConstraints = fkColumnDef.getConstraints();
                                        if (fkConstraints == null) {
                                                continue;
                                        }
                                        for (int c = 0; c < fkConstraints.size(); c++) {
                                                TConstraint inlineConstraint = fkConstraints.getConstraint(c);
                                                EConstraintType inlineType = inlineConstraint.getConstraint_type();
                                                if (inlineType != EConstraintType.foreign_key
                                                                && inlineType != EConstraintType.reference) {
                                                        continue;
                                                }
                                                TObjectName referencedTableName = inlineConstraint.getReferencedObject();
                                                TObjectNameList referencedTableColumns = inlineConstraint.getReferencedColumnList();
                                                if (referencedTableName == null || referencedTableColumns == null) {
                                                        continue;
                                                }
                                                TableColumn fkColumn = modelFactory.createTableColumn(tableModel,
                                                                fkColumnDef.getColumnName(), true);
                                                if (fkColumn == null) {
                                                        continue;
                                                }
                                                Table referencedTable = modelManager.getTableByName(
                                                                DlineageUtil.getTableIdentityKey(referencedTableName.toString()));
                                                if (referencedTable == null) {
                                                        referencedTable = modelFactory.createTableByName(referencedTableName);
                                                }
                                                for (int j = 0; j < referencedTableColumns.size(); j++) {
                                                        TableColumn referencedColumn = modelFactory.createTableColumn(referencedTable,
                                                                        referencedTableColumns.getObjectName(j), false);
                                                        if (referencedColumn != null) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.addSource(new TableColumnRelationshipElement(referencedColumn));
                                                                relation.setTarget(new TableColumnRelationshipElement(fkColumn));
                                                                relation.setEffectType(EffectType.foreign_key);
                                                                Process process = modelFactory.createProcess(stmt);
                                                                relation.setProcess(process);
                                                                if (this.option.isShowERDiagram()) {
                                                                        ERRelationship erRelation = modelFactory.createERRelation();
                                                                        erRelation.addSource(new TableColumnRelationshipElement(referencedColumn));
                                                                        erRelation.setTarget(new TableColumnRelationshipElement(fkColumn));
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }

                        if (stmt.getTableConstraints() != null && stmt.getTableConstraints().size() > 0) {
                                for (int i = 0; i < stmt.getTableConstraints().size(); i++) {
                                        TConstraint createTableConstraint = stmt.getTableConstraints().getConstraint(i);
                                        TPTNodeList<TColumnWithSortOrder> keyNames = createTableConstraint.getColumnList();
                                        if (keyNames != null) {
                                                for (int k = 0; k < keyNames.size(); k++) {
                                                        TObjectName keyName = keyNames.getElement(k).getColumnName();
                                                        // Skip functional indexes (expression-based indexes) where columnName is null
                                                        if (keyName == null) {
                                                                continue;
                                                        }
                                                        TObjectName referencedTableName = createTableConstraint.getReferencedObject();
                                                        TObjectNameList referencedTableColumns = createTableConstraint.getReferencedColumnList();

                                                        TableColumn tableConstraint = modelFactory.createTableColumn(tableModel, keyName, true);
                                                        if (createTableConstraint.getConstraint_type() == EConstraintType.primary_key) {
                                                                tableConstraint.setPrimaryKey(true);
                                                        } else if (createTableConstraint.getConstraint_type() == EConstraintType.table_index) {
                                                                tableConstraint.setIndexKey(true);
                                                        } else if (createTableConstraint.getConstraint_type() == EConstraintType.unique) {
                                                                tableConstraint.setUnqiueKey(true);
                                                        } else if (createTableConstraint.getConstraint_type() == EConstraintType.foreign_key) {
                                                                tableConstraint.setForeignKey(true);
                                                                Table referencedTable = modelManager
                                                                                .getTableByName(DlineageUtil.getTableIdentityKey(referencedTableName.toString()));
                                                                if (referencedTable == null) {
                                                                        referencedTable = modelFactory.createTableByName(referencedTableName);
                                                                }
                                                                if (k == keyNames.size() - 1) {
                                                                        captureCompositeForeignKey(tableModel, keyNames, referencedTable,
                                                                                        referencedTableColumns);
                                                                }

                                                                if (referencedTableColumns != null) {
                                                                        for (int j = 0; j < referencedTableColumns.size(); j++) {
                                                                                TableColumn tableColumn = modelFactory.createTableColumn(referencedTable,
                                                                                                referencedTableColumns.getObjectName(j), false);
                                                                                if (tableColumn != null) {
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                                        relation.setEffectType(EffectType.foreign_key);
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                        if (this.option.isShowERDiagram()) {
                                                                                                ERRelationship erRelation = modelFactory.createERRelation();
                                                                                                erRelation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                erRelation
                                                                                                                .setTarget(new TableColumnRelationshipElement(tableConstraint));
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }

                        if (stmt.getHiveTablePartition() != null && stmt.getHiveTablePartition().getColumnDefList() != null) {
                                for (int i = 0; i < stmt.getHiveTablePartition().getColumnDefList().size(); i++) {
                                        TColumnDefinition column = stmt.getHiveTablePartition().getColumnDefList().getColumn(i);
                                        modelFactory.createTableColumn(tableModel, column.getColumnName(), true);
                                        appendTableColumnToSQLEnv(tableModel, column.getColumnName());
                                }
                        }

                        analyzeDynamicTableRefresh(stmt, tableModel);

                } else {
                        ErrorInfo errorInfo = new ErrorInfo();
                        errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                        errorInfo.setErrorMessage("Can't get target table. CreateTableSqlStatement is " + stmt.toString());
                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(stmt.getStartToken().lineNo,
                                        stmt.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(stmt.getEndToken().lineNo,
                                        stmt.getEndToken().columnNo + stmt.getEndToken().getAstext().length(),
                                        ModelBindingManager.getGlobalHash()));
                        errorInfos.add(errorInfo);
                }
        }

        private void analyzeDynamicTableRefresh(TCreateTableSqlStatement stmt,
                        Table dynamicTable) {
                TCustomSqlStatement refreshStatement = stmt.getRefreshUsingStatement();
                if (refreshStatement == null || refreshStatement.getTargetTable() == null) {
                        return;
                }
                String targetToken = refreshStatement.getTargetTable().getTableName()
                                .toString();
                if (!"SELF".equalsIgnoreCase(targetToken)) { // non-identifier-compare: Snowflake pseudo-target keyword
                        return;
                }

                // Snowflake defines SELF as the dynamic table currently being created.
                // Bind the lexical SELF target to that existing model before running the
                // normal INSERT/MERGE analyzer, so all emitted target edges use the real
                // dynamic-table identity and its declared columns.
                modelManager.bindModel(refreshStatement.getTargetTable(), dynamicTable);
                analyzeCustomSqlStmt(refreshStatement);
        }

        private void captureCompositeForeignKey(Table foreignKeyTable,
                        TPTNodeList<TColumnWithSortOrder> foreignKeyNames, Table referencedTable,
                        TObjectNameList referencedNames) {
                if (!shouldCollectAuthoritativeLineageEvidence() || foreignKeyTable == null
                                || referencedTable == null || foreignKeyNames == null
                                || referencedNames == null || foreignKeyNames.size() < 2
                                || foreignKeyNames.size() != referencedNames.size()) return;
                List<TableColumn> foreignKeyFields = new ArrayList<TableColumn>();
                List<TableColumn> referencedFields = new ArrayList<TableColumn>();
                for (int ordinal = 0; ordinal < foreignKeyNames.size(); ordinal++) {
                        TColumnWithSortOrder foreignKey = foreignKeyNames.getElement(ordinal);
                        if (foreignKey == null || foreignKey.getColumnName() == null
                                        || referencedNames.getObjectName(ordinal) == null) return;
                        TableColumn local = findExistingTableColumn(foreignKeyTable,
                                        foreignKey.getColumnName());
                        TableColumn referenced = findExistingTableColumn(referencedTable,
                                        referencedNames.getObjectName(ordinal));
                        if (local == null || referenced == null) return;
                        foreignKeyFields.add(local);
                        referencedFields.add(referenced);
                }
                authoritativeEvidenceCollector.addCompositeForeignKey(foreignKeyFields, referencedFields);
        }

        /** Lookup-only: evidence capture must never create or mutate legacy model nodes. */
        private TableColumn findExistingTableColumn(Table table, TObjectName columnName) {
                Object exact = modelManager.getModel(new Pair<Table, TObjectName>(table, columnName));
                if (exact instanceof TableColumn && ((TableColumn) exact).getTable() == table) {
                        return (TableColumn) exact;
                }
                if (table.getColumns() == null) return null;
                for (TableColumn candidate : table.getColumns()) {
                        if (candidate != null && DlineageUtil.sameColumnName(candidate.getName(), columnName)) {
                                return candidate;
                        }
                }
                return null;
        }

        /**
         * Whether a CREATE TABLE {@code STRUCT} or {@code ARRAY<STRUCT>} column is modelled as one column per field
         * path ({@code payload.name}). The Trino family (Athena, Presto, Trino) models the declared column itself:
         * TSQLResolver2 reads {@code payload.items[1].name} and {@code payload.address.city} there as the column
         * {@code payload} with a field path, so its read lands on the declared column, while the flattened names,
         * published by their last segment ({@code items}, {@code name}), were columns the table never had and every
         * read of {@code payload} was dropped from the determined table (Mantis 4811, 4822).
         */
        private boolean modelsNestedFieldsAsColumns() {
                return !nestedProfile().buildsDeclaredTree();
        }

        /**
         * STRUCT tree, plan rule R3: whether TSQLResolver2 read {@code column} as a field of a column that several
         * relations in scope provide, such as {@code customer.name} in {@code FROM orders, items} when both declare
         * {@code customer}. Such a read has no proven owner.
         */
        private boolean isUndecidedFieldRead(TObjectName column) {
                if (!nestedProfile().buildsDeclaredTree() || column.getResolution() == null
                                || !column.getResolution().isAmbiguous() || column.getResolution().getAmbiguousSource() == null) {
                        return false;
                }
                List<gudusoft.gsqlparser.resolver2.model.ColumnSource> candidates =
                                column.getResolution().getAmbiguousSource().getCandidates();
                return candidates != null && !candidates.isEmpty() && candidates.get(0).isStructFieldAccess();
        }

        /**
         * STRUCT tree, plan section 8: {@code customer.*} reads every field of {@code customer}. When its declared STRUCT
         * type lists the fields, the item is one result column per field, each from that field's node; otherwise it is
         * one {@code *} column from the node of {@code customer}, which stands for all of them. When several relations
         * could provide {@code customer} the column has no source (plan rule R3).
         *
         * @return null when the item is not a wildcard below a column; otherwise whether its result columns are known
         */
        /**
         * STRUCT tree: whether a select item {@code customer.*} stands for the unknown fields of a column, published as
         * one non-wildcard result column by {@link #analyzeStructStar} (Mantis 4827).
         */
        private boolean structStarOfUnknownFields(TObjectName item, ResultColumn resultColumn) {
                return nestedProfile().buildsDeclaredTree() && item.getStructStarPath() != null
                                && !resultColumn.isStarColumn() && !resultColumn.isStruct();
        }

        private Boolean analyzeStructStar(ResultSet resultSetModel, TResultColumn column) {
                if (!nestedProfile().buildsDeclaredTree() || column.getExpr() == null
                                || column.getExpr().getExpressionType() != EExpressionType.simple_object_name_t
                                || column.getExpr().getObjectOperand() == null) {
                        return null;
                }
                TObjectName star = column.getExpr().getObjectOperand();
                if (star.getStructStarPath() == null) {
                        if (star.getStarQualifierChain().isEmpty() || !isUndecidedFieldRead(star)) {
                                return null;
                        }
                        modelFactory.createStructStarResultColumn(resultSetModel, column);
                        return Boolean.FALSE;
                }
                TableColumn node = null;
                // the relation TSQLResolver2 found the column in; the parse may have bound the wildcard to a table named like a
                // field (payload.events.* FROM source, events)
                TTable owner = star.getColumnSource() != null && star.getColumnSource().getFinalTable() != null
                                ? star.getColumnSource().getFinalTable() : star.getSourceTable();
                if (owner != null && owner.getCTE() == null && !owner.isCTEName() && owner.getSubquery() == null) {
                        Object model = modelManager.getModel(owner);
                        if (model == null && owner.getTableType() == ETableSource.objectname) {
                                model = modelFactory.createTable(owner);
                        }
                        if (model instanceof Table) {
                                node = modelFactory.createTableColumn((Table) model, star, false);
                        }
                }
                if (node == null) {
                        return null;
                }
                List<TableColumn> fields = node.getDeclaredFields();
                if (!fields.isEmpty()) {
                        for (TableColumn field : fields) {
                                List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> path =
                                                field.getFieldPath().getSegments();
                                ResultColumn resultColumn = modelFactory.createStructFieldResultColumn(resultSetModel, column,
                                                path.get(path.size() - 1).getName());
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.select);
                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                relation.addSource(new TableColumnRelationshipElement(field));
                        }
                        return Boolean.TRUE;
                }
                ResultColumn resultColumn = modelFactory.createStructStarResultColumn(resultSetModel, column);
                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(EffectType.select);
                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                relation.addSource(new TableColumnRelationshipElement(node));
                return Boolean.FALSE;
        }

        /**
         * Plan rule R8: a field of a STRUCT a select item builds. The item publishes one result column per field (a leaf
         * of a nested STRUCT included); this record says which item it belongs to, under which alias (null for an item
         * without one), at which path below it. CTAS and CREATE VIEW make each field a field node of the declared column {@code alias}; positional mappers
         * pair the item, all of its fields, with one target column (Mantis 4834, 4847, 4891, 4892).
         */
        static final class StructFieldPath {
                final TObjectName alias;
                final List<String> path;
                final TResultColumn item;

                StructFieldPath(TObjectName alias, List<String> path, TResultColumn item) {
                        this.alias = alias;
                        this.path = Collections.unmodifiableList(new ArrayList<String>(path));
                        this.item = item;
                }

                List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> segments() {
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> segments =
                                        new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>(path.size());
                        for (String field : path) {
                                segments.add(gudusoft.gsqlparser.common.structured.StructuredPathSegment.field(field));
                        }
                        return segments;
                }
        }

        /**
         * Plan rule R8: how many result columns, from {@code columns.get(j)}, the select item of that column publishes:
         * every field of a STRUCT it builds ({@link #structFieldPaths}), else one.
         */
        private int selectItemWidth(List<ResultColumn> columns, int j) {
                StructFieldPath first = j < columns.size() ? structFieldPaths.get(columns.get(j)) : null;
                if (first == null) {
                        return 1;
                }
                int width = 1;
                while (j + width < columns.size()) {
                        StructFieldPath next = structFieldPaths.get(columns.get(j + width));
                        if (next == null || next.item != first.item) {
                                break;
                        }
                        width++;
                }
                return width;
        }

        /**
         * Plan rule R8, Mantis 4891: {@code target}, the column a list pairs with a select item that builds a STRUCT, takes
         * the item's fields. When the target declares as many leaf fields as the item has, leaf k takes field k, by position,
         * as BigQuery, Hive and Trino assign a STRUCT; otherwise each field feeds the target's node at its own path where
         * the target can have that field, and the whole target column where it cannot. A provable value is never dropped,
         * and no leaf is invented under a declared STRUCT.
         */
        private void feedFromStructItem(TableColumn target, List<ResultColumn> fields, TObjectName position,
                        EffectType effectType, Process process, boolean viewColumn) {
                List<TableColumn> leaves = new ArrayList<TableColumn>();
                addDeclaredLeaves(target, leaves);
                boolean positional = leaves.size() == fields.size() && !(leaves.size() == 1 && leaves.get(0) == target);
                for (int k = 0; k < fields.size(); k++) {
                        ResultColumn field = fields.get(k);
                        TableColumn node = positional ? leaves.get(k) : null;
                        StructFieldPath path = structFieldPaths.get(field);
                        if (node == null && path != null) {
                                node = modelFactory.createFieldPath(target, path.segments(), position);
                        }
                        if (node == null) {
                                node = target;
                        }
                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                        relation.setEffectType(effectType);
                        relation.setTarget(viewColumn ? new ViewColumnRelationshipElement(node) : new TableColumnRelationshipElement(node));
                        relation.addSource(new ResultColumnRelationshipElement(field));
                        relation.setProcess(process);
                }
        }

        /**
         * Plan section 4.4, Mantis 4893: a select item that only names a column, {@code payload} of a CTE or derived table
         * whose query built that column as a STRUCT ({@code named_struct('a', x, 'b', y) AS payload}), passes the fields
         * on: one result column per field, each fed by the field it passes on, registered as fields of this item, so a CTAS
         * or a view over it makes them field nodes. Only for fields the query built (a declared STRUCT column read whole
         * stays one column, rule 1 of the STRUCT page); false, and nothing done, otherwise.
         */
        private boolean propagateStructItem(ResultSet resultSet, TResultColumn column) {
                List<ResultColumn> fields = new ArrayList<ResultColumn>();
                List<StructFieldPath> paths = new ArrayList<StructFieldPath>();
                if (!passedStructFields(column, fields, paths)) {
                        return false;
                }
                TObjectName name = column.getFieldAttr();
                String base = name.getColumnNameOnly();
                TObjectName alias = column.getAliasClause() != null && column.getAliasClause().getAliasName() != null
                                ? column.getAliasClause().getAliasName() : name;
                String aliasName = column.getAliasClause() != null && column.getAliasClause().getAliasName() != null
                                ? alias.toString() : base;
                for (int k = 0; k < fields.size(); k++) {
                        StringBuilder fieldName = new StringBuilder(aliasName);
                        for (String step : paths.get(k).path) {
                                fieldName.append('.').append(step);
                        }
                        TObjectName columnName = new TObjectName();
                        columnName.setString(fieldName.toString());
                        ResultColumn field = modelFactory.createResultColumn(resultSet, columnName);
                        field.setStruct(true);
                        putStructField(field, new StructFieldPath(alias, paths.get(k).path, column));
                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                        relation.setEffectType(EffectType.select);
                        relation.setTarget(new ResultColumnRelationshipElement(field));
                        relation.addSource(new ResultColumnRelationshipElement(fields.get(k)));
                }
                return true;
        }

        /**
         * Rule R8: the STRUCT fields a select item that only names a column passes on, into {@code fields} and
         * {@code paths} in order: the field columns of a CTE or derived table whose query built that column as a STRUCT,
         * or the field nodes below a column of that name ({@link #addStructFieldNodes}). False, nothing added, when the
         * item names no such column (a declared STRUCT column read whole stays one column, rule 1 of the STRUCT page).
         */
        private boolean passedStructFields(TResultColumn column, List<ResultColumn> fields, List<StructFieldPath> paths) {
                if (!nestedProfile().buildsDeclaredTree() || column.getExpr() == null
                                || column.getExpr().getExpressionType() != EExpressionType.simple_object_name_t
                                || column.getFieldAttr() == null || column.getFieldAttr().getSourceTable() == null
                                || column.getFieldAttr().getFieldPathRead() != null || DlineageUtil.isStarName(column.getFieldAttr())) {
                        return false;
                }
                TObjectName name = column.getFieldAttr();
                Object source = modelManager.getModel(name.getSourceTable());
                if (!(source instanceof ResultSet)) {
                        return false;
                }
                String base = name.getColumnNameOnly();
                List<ResultColumn> found = new ArrayList<ResultColumn>();
                List<StructFieldPath> foundPaths = new ArrayList<StructFieldPath>();
                for (ResultColumn candidate : ((ResultSet) source).getColumns()) {
                        if (!candidate.isStruct()) {
                                if (DlineageUtil.sameName(ESQLDataObjectType.dotColumn, candidate.getName(), base)) {
                                        // a column of that name itself: the item reads it, and the fields built below it
                                        List<ResultColumn> nodes = builtFieldNodes.get(candidate);
                                        if (nodes == null) {
                                                return false;
                                        }
                                        for (ResultColumn node : nodes) {
                                                fields.add(node);
                                                paths.add(structFieldPaths.get(node));
                                        }
                                        return true;
                                }
                                continue;
                        }
                        StructFieldPath path = structFieldPathOf(candidate);
                        if (path != null && path.alias != null
                                        && DlineageUtil.sameName(ESQLDataObjectType.dotColumn, path.alias.toString(), base)) {
                                found.add(candidate);
                                foundPaths.add(path);
                        }
                }
                fields.addAll(found);
                paths.addAll(foundPaths);
                return !found.isEmpty();
        }

        /**
         * Rule R8 for the query of a derived table, whose select items fill a relation made before them: the item keeps
         * its one column, as before, and a STRUCT it builds, or passes on ({@link #passedStructFields}), adds a field node
         * below that column per field, fed by the field's value. A projection or a field read of the column then reads the
         * fields (Mantis 4893); nothing the column published is taken away.
         */
        private void addStructFieldNodes(ResultSet resultSet, TResultColumn column) {
                if (!nestedProfile().buildsDeclaredTree()) {
                        return;
                }
                Object model = modelManager.getModel(column);
                if (!(model instanceof ResultColumn) || ((ResultColumn) model).getResultSet() != resultSet
                                || ((ResultColumn) model).isStarColumn() || builtFieldNodes.containsKey(model)) {
                        return;
                }
                ResultColumn whole = (ResultColumn) model;
                TObjectName alias = column.getAliasClause() != null && column.getAliasClause().getAliasName() != null
                                ? column.getAliasClause().getAliasName() : column.getFieldAttr();
                List<Object[]> built = structItemFields(column);
                if (built != null) {
                        for (Object[] field : built) {
                                @SuppressWarnings("unchecked")
                                List<String> path = (List<String>) field[0];
                                ResultColumn node = structFieldNode(whole, path, alias, column);
                                columnsInExpr visitor = new columnsInExpr();
                                ((TExpression) field[1]).inOrderTraverse(visitor);
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(node, functions, EffectType.select);
                                }
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(node, subquerys, EffectType.select);
                                }
                                analyzeDataFlowRelation(node, visitor.getObjectNames(), EffectType.select, functions);
                                analyzeConstantDataFlowRelation(node, visitor.getConstants(), EffectType.select, functions);
                        }
                        return;
                }
                List<ResultColumn> fields = new ArrayList<ResultColumn>();
                List<StructFieldPath> paths = new ArrayList<StructFieldPath>();
                if (alias != null && passedStructFields(column, fields, paths)) {
                        for (int k = 0; k < fields.size(); k++) {
                                ResultColumn node = structFieldNode(whole, paths.get(k).path, alias, column);
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.select);
                                relation.setTarget(new ResultColumnRelationshipElement(node));
                                relation.addSource(new ResultColumnRelationshipElement(fields.get(k)));
                        }
                }
        }

        /** The field node at {@code path} below {@code whole}, a field of the STRUCT the select item {@code item} builds. */
        private ResultColumn structFieldNode(ResultColumn whole, List<String> path, TObjectName alias, TResultColumn item) {
                StringBuilder name = new StringBuilder(whole.getName());
                for (String step : path) {
                        name.append('.').append(step);
                }
                TSourceToken token = new TSourceToken(name.toString());
                if (item.getStartToken() != null) {
                        token.lineNo = item.getStartToken().lineNo;
                        token.columnNo = item.getStartToken().columnNo;
                }
                // a node of its own: never name-matched to a column, as the field nodes of a field read (Mantis 4836)
                ResultColumn node = modelFactory.createDeterminedResultColumn(whole.getResultSet(),
                                TObjectName.createObjectName(option.getVendor(), EDbObjectType.column, token));
                node.setStruct(true);
                StructFieldPath fieldPath = new StructFieldPath(alias, path, item);
                whole.getResultSet().addFieldPathColumn(node, whole, fieldPath.segments());
                putStructField(node, fieldPath);
                List<ResultColumn> nodes = builtFieldNodes.get(whole);
                if (nodes == null) {
                        nodes = new ArrayList<ResultColumn>();
                        builtFieldNodes.put(whole, nodes);
                }
                nodes.add(node);
                return node;
        }

        /**
         * The field node of {@code base} a field read reaches: the node at the read's path, or the leaf whose value the
         * read goes into; null when no node is, or when the read stops above the leaves.
         */
        private ResultColumn builtFieldNode(ResultColumn base,
                        gudusoft.gsqlparser.common.structured.StructuredColumnPath read) {
                List<ResultColumn> nodes = builtFieldNodes.get(base);
                if (nodes == null || read == null) {
                        return null;
                }
                for (ResultColumn node : nodes) {
                        List<String> path = structFieldPaths.get(node).path;
                        if (path.size() > read.getSegments().size()) {
                                continue;
                        }
                        boolean match = true;
                        for (int i = 0; i < path.size() && match; i++) {
                                gudusoft.gsqlparser.common.structured.StructuredPathSegment segment = read.getSegments().get(i);
                                match = segment.getKind() == gudusoft.gsqlparser.common.structured.StructuredPathSegmentKind.FIELD
                                                && DlineageUtil.sameName(ESQLDataObjectType.dotColumn, segment.getName(), path.get(i));
                        }
                        if (match) {
                                return node;
                        }
                }
                return null;
        }

        /**
         * Rule R8: the fields of the STRUCT the select item builds, each {path below the item, value}, in source order, a
         * nested constructor's leaves below its field: a constructor of the registry ({@link #constructorFields}), aliased
         * or not; an unnamed field has no node. Null when the item builds none.
         */
        private List<Object[]> structItemFields(TResultColumn column) {
                if (column.getExpr() == null || column.getExpr().getExpressionType() != EExpressionType.function_t
                                || constructorFields(column.getExpr().getFunctionCall()) == null) {
                        return null;
                }
                List<Object[]> fields = new ArrayList<Object[]>();
                constructorLeaves(column.getExpr().getFunctionCall(), new ArrayList<String>(), fields);
                return fields.isEmpty() ? null : fields;
        }

        /** The column at {@code index} of a branch of a set operation, or null for a wildcard or a missing one. */
        private ResultColumn setOperationBranchColumn(TSelectSqlStatement branch, int index) {
                ResultSet model = setOperationBranch(branch);
                if (model == null || model.getColumns().size() <= index) {
                        return null;
                }
                ResultColumn column = model.getColumns().get(index);
                return column.isStarColumn() ? null : column;
        }

        /** The result set of a branch of a set operation, or null. */
        private ResultSet setOperationBranch(TSelectSqlStatement branch) {
                Object model = branch.isCombinedQuery() ? modelManager.getModel(branch)
                                : modelManager.getModel(branch.getResultColumnList());
                return model instanceof ResultSet ? (ResultSet) model : null;
        }

        /** The result set of the branch the columns of the set operation {@code stmt} are named after, or null. */
        private ResultSet setOperationNamingBranch(TSelectSqlStatement stmt) {
                return setOperationBranch(getResultColumnList(stmt.getLeftStmt()) != null ? stmt.getLeftStmt() : stmt.getRightStmt());
        }

        /** {@link #setOperationNamingBranch} of the set operation {@code resultSet} is the result of; null for another result set. */
        private ResultSet setOperationNamingBranch(ResultSet resultSet) {
                return resultSet instanceof SelectSetResultSet && resultSet.getGspObject() instanceof TSelectSqlStatement
                                ? setOperationNamingBranch((TSelectSqlStatement) resultSet.getGspObject()) : null;
        }

        /**
         * Mantis 4914: for each branch of the set operation {@code stmt} and each of its {@code columns}, the columns of the
         * branch that can stand at the column's position; null when no branch and no column is a star of unknown width,
         * and the columns pair one by one. Every branch is as wide as the others, so a star spans what the items beside it
         * leave ({@link #setItemSpans}). Pairing by index put a column of the branch without a star at the position the
         * other branch's star covers, and fed a star with the columns after it.
         */
        private List<List<List<ResultColumn>>> setOperationSpanSources(TSelectSqlStatement stmt, List<ResultColumn> columns) {
                List<List<ResultColumn>> columnItems = new ArrayList<List<ResultColumn>>(columns.size());
                for (ResultColumn column : columns) {
                        columnItems.add(Collections.singletonList(column));
                }
                TSelectSqlStatement[] branchStmts = {stmt.getLeftStmt(), stmt.getRightStmt()};
                List<ResultSet> branches = new ArrayList<ResultSet>(2);
                List<List<List<ResultColumn>>> branchItems = new ArrayList<List<List<ResultColumn>>>(2);
                boolean star = fixedSetItems(columnItems) < columnItems.size();
                // the width of a branch without a star of unknown width, which is every branch's
                int width = -1;
                int fixed = fixedSetItems(columnItems);
                for (TSelectSqlStatement branchStmt : branchStmts) {
                        ResultSet branch = setOperationBranch(branchStmt);
                        List<List<ResultColumn>> items = branch == null ? null : selectItemGroups(branch.getColumns());
                        branches.add(branch);
                        branchItems.add(items);
                        if (items != null) {
                                int branchFixed = fixedSetItems(items);
                                star |= branchFixed < items.size();
                                if (branchFixed == items.size() && width < 0) {
                                        width = items.size();
                                }
                                fixed = Math.max(fixed, branchFixed);
                        }
                }
                if (star && width < 0) {
                        // a select deeper in the set operation, or in another branch of it, can prove the width (Codex review)
                        width = setOperationTreeWidth(stmt);
                }
                if (!star || width >= 0 && fixed > width) {
                        return null;
                }
                int minWidth = width >= 0 ? width : fixed;
                int maxWidth = width >= 0 ? width : Integer.MAX_VALUE;
                List<int[]> columnSpans = setItemSpans(columnItems);
                // the columns are named after one branch, item by item
                ResultSet namingBranch = setOperationNamingBranch(stmt);
                List<List<ResultColumn>> namingItems = namingBranch == null ? null : selectItemGroups(namingBranch.getColumns());
                List<List<List<ResultColumn>>> sources = new ArrayList<List<List<ResultColumn>>>(2);
                for (int b = 0; b < 2; b++) {
                        List<List<ResultColumn>> items = branchItems.get(b);
                        boolean itemByItem = items != null && branches.get(b) == namingBranch
                                        && namingBranch.getColumns().size() == columns.size();
                        // a branch laid out like the naming one, its stars reading the same tables, pairs item by item even
                        // between two stars, which are as wide as each other (Codex review)
                        boolean sameLayout = !itemByItem && items != null && namingItems != null
                                        && namingItems.size() == columns.size() && sameItemLayout(namingItems, items);
                        List<int[]> spans = items == null ? null : setItemSpans(items);
                        List<List<ResultColumn>> branchSources = new ArrayList<List<ResultColumn>>(columns.size());
                        for (int i = 0; i < columns.size(); i++) {
                                List<ResultColumn> candidates = new ArrayList<ResultColumn>();
                                if (itemByItem) {
                                        candidates.add(branches.get(b).getColumns().get(i));
                                } else if (sameLayout) {
                                        candidates.addAll(items.get(i));
                                } else if (items != null) {
                                        for (int k = 0; k < items.size(); k++) {
                                                if (spansMeet(columnSpans.get(i), spans.get(k), minWidth, maxWidth)) {
                                                        candidates.addAll(items.get(k));
                                                }
                                        }
                                }
                                branchSources.add(candidates);
                        }
                        sources.add(branchSources);
                }
                return sources;
        }

        /**
         * The width of every select of the set operation tree {@code stmt} is part of, from a select of it without a star of
         * unknown width; -1 when none proves it. A set operation's columns collapse a star of its first select, so a select
         * deeper in a branch, or in another branch, can be the only one to prove the width (Codex review of Mantis 4914).
         */
        private int setOperationTreeWidth(TSelectSqlStatement stmt) {
                TSelectSqlStatement root = stmt;
                for (TSelectSqlStatement parent = getParentSetSelectStmt(root); parent != null
                                && parent.isCombinedQuery(); parent = getParentSetSelectStmt(root)) {
                        root = parent;
                }
                Deque<TSelectSqlStatement> stack = new ArrayDeque<TSelectSqlStatement>();
                stack.push(root);
                while (!stack.isEmpty()) {
                        TSelectSqlStatement current = stack.pop();
                        if (current.isCombinedQuery()) {
                                if (current.getRightStmt() != null) {
                                        stack.push(current.getRightStmt());
                                }
                                if (current.getLeftStmt() != null) {
                                        stack.push(current.getLeftStmt());
                                }
                                continue;
                        }
                        TResultColumnList list = current.getResultColumnList();
                        if (list == null) {
                                continue;
                        }
                        boolean starItem = false;
                        for (int i = 0; i < list.size() && !starItem; i++) {
                                starItem = isStarItem(list.getResultColumn(i));
                        }
                        if (!starItem) {
                                return list.size();
                        }
                        // a star the analysis expanded (DDL) has a known width
                        Object model = modelManager.getModel(list);
                        if (model instanceof ResultSet) {
                                List<List<ResultColumn>> items = selectItemGroups(((ResultSet) model).getColumns());
                                if (fixedSetItems(items) == items.size()) {
                                        return items.size();
                                }
                        }
                }
                return -1;
        }

        /**
         * Whether two selects of a set operation lay out their items alike: as many items, and a star of unknown width at the
         * same place in both, reading the same tables without EXCEPT or REPLACE. Such stars are as wide as each other.
         */
        private boolean sameItemLayout(List<List<ResultColumn>> a, List<List<ResultColumn>> b) {
                if (a.size() != b.size()) {
                        return false;
                }
                for (int k = 0; k < a.size(); k++) {
                        boolean star = isUnknownWidthStar(a.get(k).get(0));
                        if (star != isUnknownWidthStar(b.get(k).get(0))) {
                                return false;
                        }
                        if (star) {
                                List<Object> tables = starTableModels(a.get(k).get(0));
                                List<Object> others = starTableModels(b.get(k).get(0));
                                if (tables == null || others == null || tables.size() != others.size()) {
                                        return false;
                                }
                                for (int t = 0; t < tables.size(); t++) {
                                        if (tables.get(t) != others.get(t)) {
                                                return false;
                                        }
                                }
                        }
                }
                return true;
        }

        /** The models of the tables a star item reads, in FROM order; null for another item, or a star with EXCEPT or REPLACE. */
        private List<Object> starTableModels(ResultColumn column) {
                if (!(column.getColumnObject() instanceof TResultColumn) || !isStarItem((TResultColumn) column.getColumnObject())) {
                        return null;
                }
                TResultColumn star = (TResultColumn) column.getColumnObject();
                if (star.getExceptColumnList() != null
                                || (star.getReplaceExprAsIdentifiers() != null && !star.getReplaceExprAsIdentifiers().isEmpty())) {
                        return null;
                }
                List<TTable> tables = star.getFieldAttr().getSourceTableList();
                if (tables == null || tables.isEmpty()) {
                        return null;
                }
                List<Object> models = new ArrayList<Object>();
                for (TTable table : tables) {
                        Object model = modelManager.getModel(table);
                        if (!(model instanceof Table)) {
                                return null;
                        }
                        models.add(model);
                }
                return models;
        }

        /** How many of {@code items} are not stars of unknown width, each one column wide. */
        private static int fixedSetItems(List<List<ResultColumn>> items) {
                int fixed = 0;
                for (List<ResultColumn> item : items) {
                        if (!isUnknownWidthStar(item.get(0))) {
                                fixed++;
                        }
                }
                return fixed;
        }

        private static boolean isUnknownWidthStar(ResultColumn column) {
                return column.getName() != null && column.isStarColumn();
        }

        /**
         * Mantis 4914: the positions each select item of a set operation's list can stand at, as {start, end}, each end
         * c + w * W for the width W of the list: {c, 0} counts from the first column, {-1 - c, 1} back from the last. An
         * item before every star of unknown width stands where it is written, an item after every star counts back from
         * the end, and a star, or an item between two stars, spans what the items beside it leave.
         */
        private static List<int[]> setItemSpans(List<List<ResultColumn>> items) {
                int fixed = fixedSetItems(items);
                int lastStar = -1;
                for (int k = 0; k < items.size(); k++) {
                        if (isUnknownWidthStar(items.get(k).get(0))) {
                                lastStar = k;
                        }
                }
                List<int[]> spans = new ArrayList<int[]>(items.size());
                int before = 0;
                boolean starBefore = false;
                for (int k = 0; k < items.size(); k++) {
                        boolean star = isUnknownWidthStar(items.get(k).get(0));
                        int after = fixed - before - (star ? 0 : 1);
                        if (!star && !starBefore) {
                                spans.add(new int[] {before, 0, before, 0});
                        } else if (!star && k > lastStar) {
                                spans.add(new int[] {-1 - after, 1, -1 - after, 1});
                        } else {
                                spans.add(new int[] {before, 0, -1 - after, 1});
                        }
                        if (star) {
                                starBefore = true;
                        } else {
                                before++;
                        }
                }
                return spans;
        }

        /** Whether two spans of {@link #setItemSpans} can share a position for a width from {@code minWidth} to {@code maxWidth}. */
        private static boolean spansMeet(int[] a, int[] b, int minWidth, int maxWidth) {
                int[] widths = {minWidth, maxWidth};
                // neither span is empty, and each starts no later than the other ends
                return notAfter(a, 0, a, 2, widths) && notAfter(b, 0, b, 2, widths) && notAfter(a, 0, b, 2, widths)
                                && notAfter(b, 0, a, 2, widths);
        }

        /**
         * Narrows {@code widths} to the widths W for which end {@code i} of span {@code a} is at most end {@code j} of span
         * {@code b}; false when no width is left.
         */
        private static boolean notAfter(int[] a, int i, int[] b, int j, int[] widths) {
                // a[i] + a[i + 1] * W <= b[j] + b[j + 1] * W
                int w = a[i + 1] - b[j + 1];
                int c = b[j] - a[i];
                if (w == 0 && c < 0) {
                        return false;
                }
                if (w > 0) {
                        widths[1] = Math.min(widths[1], c);
                } else if (w < 0) {
                        widths[0] = Math.max(widths[0], -c);
                }
                return widths[0] <= widths[1];
        }

        /**
         * Rule R8 through a set operation: a field node below {@code target}, the set operation's column, per field node
         * below {@code branch}, the column of a branch at its position, fed by it; branches with the same field share the
         * node.
         */
        private void setOperationFieldNodes(ResultColumn target, ResultColumn branch) {
                List<ResultColumn> nodes = branch == null || target.isStarColumn() ? null : builtFieldNodes.get(branch);
                if (nodes == null) {
                        return;
                }
                for (ResultColumn node : nodes) {
                        StructFieldPath path = structFieldPaths.get(node);
                        ResultColumn targetNode = builtFieldNodeAt(target, path.path);
                        if (targetNode == null) {
                                targetNode = structFieldNode(target, path.path, path.alias, path.item);
                        }
                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                        relation.setEffectType(EffectType.select);
                        relation.setTarget(new ResultColumnRelationshipElement(targetNode));
                        relation.addSource(new ResultColumnRelationshipElement(node));
                }
        }

        /** The field node {@link #structFieldNode} built below {@code column} at exactly {@code path}, or null. */
        private ResultColumn builtFieldNodeAt(ResultColumn column, List<String> path) {
                List<ResultColumn> nodes = builtFieldNodes.get(column);
                if (nodes == null) {
                        return null;
                }
                for (ResultColumn node : nodes) {
                        List<String> nodePath = structFieldPaths.get(node).path;
                        if (nodePath.size() != path.size()) {
                                continue;
                        }
                        boolean same = true;
                        for (int i = 0; i < path.size() && same; i++) {
                                same = DlineageUtil.sameName(ESQLDataObjectType.dotColumn, nodePath.get(i), path.get(i));
                        }
                        if (same) {
                                return node;
                        }
                }
                return null;
        }

        /**
         * Rule R8 at a write: {@code target}, the column {@code source} feeds, gets a field node per field node built
         * below {@code source} ({@link #addStructFieldNodes}, {@link #setOperationFieldNodes}), fed by it. A field the
         * target's DDL does not declare gets none: its value still reaches the whole column.
         */
        private void feedBuiltFieldNodes(TableColumn target, ResultColumn source, EffectType effectType, Process process,
                        boolean viewColumn) {
                List<ResultColumn> nodes = target == null || target.isStarColumn() ? null : builtFieldNodes.get(source);
                if (nodes == null) {
                        return;
                }
                for (ResultColumn node : nodes) {
                        TableColumn targetNode = modelFactory.createFieldPath(target, structFieldPaths.get(node).segments(),
                                        target.getColumnObject());
                        if (targetNode == null) {
                                continue;
                        }
                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                        relation.setEffectType(effectType);
                        relation.setTarget(viewColumn ? new ViewColumnRelationshipElement(targetNode)
                                        : new TableColumnRelationshipElement(targetNode));
                        relation.addSource(new ResultColumnRelationshipElement(node));
                        relation.setProcess(process);
                }
        }

        /** The field nodes {@link #addStructFieldNodes} built below a result column, in order. */
        private final Map<ResultColumn, List<ResultColumn>> builtFieldNodes = new IdentityHashMap<ResultColumn, List<ResultColumn>>();

        /**
         * The STRUCT field a result column stands for: its own record, or, for a column of a CTE or derived table that
         * copies one with a single select edge, the record of the column it copies (depth-bounded).
         */
        private StructFieldPath structFieldPathOf(ResultColumn column) {
                ResultColumn current = column;
                for (int depth = 0; current != null && depth < 16; depth++) {
                        StructFieldPath path = structFieldPaths.get(current);
                        if (path != null) {
                                return path;
                        }
                        ResultColumn upstream = null;
                        for (Relationship relation : modelManager.getRelations()) {
                                if (!(relation instanceof DataFlowRelationship) || relation.getTarget() == null
                                                || relation.getTarget().getElement() != current) {
                                        continue;
                                }
                                if (((DataFlowRelationship) relation).getEffectType() != EffectType.select
                                                || relation.getSources().size() != 1 || upstream != null) {
                                        return null;
                                }
                                Object source = ((RelationshipElement<?>) relation.getSources().iterator().next()).getElement();
                                if (!(source instanceof ResultColumn)) {
                                        return null;
                                }
                                upstream = (ResultColumn) source;
                        }
                        current = upstream;
                }
                return null;
        }

        /**
         * Plan rule R8: whether the select item builds a STRUCT whose fields it publishes, one result column per field: a
         * Trino family {@code CAST(ROW(..) AS ROW(..))} with field names, a STRUCT constructor, an aliased
         * {@code named_struct} or Hive family {@code struct(..)}.
         */
        private boolean buildsStructItem(TResultColumn column) {
                if (column.getExpr() == null) {
                        return false;
                }
                if (rowCastFieldNames(column) != null) {
                        return true;
                }
                TFunctionCall call = column.getExpr().getFunctionCall();
                return call != null && (call.getFunctionType() == EFunctionType.struct_t
                                || ((isNamedStruct(call) || isPositionalStruct(call)) && column.getAliasClause() != null));
        }

        /**
         * Plan rule R8: the result columns of a select item that {@link #buildsStructItem builds a STRUCT}, one per field
         * (per leaf of a nested one), each fed by its value and registered in {@link #structFieldPaths}. One method for
         * every query block, a CTE, a derived table or the top query, so a STRUCT a derived table builds keeps its fields
         * as one a CTE builds does (Mantis 4893).
         */
        private void analyzeStructItem(ResultSet resultSetModel, TResultColumn column) {
                if (rowCastFieldNames(column) != null) {
                        // Trino family CAST(ROW(a, b) AS ROW(city VARCHAR, phone VARCHAR)) AS contact: one
                        // column per field, contact.city <- a, as BigQuery STRUCT(a AS city) AS contact
                        // (Mantis 4834)
                        List<String> fields = rowCastFieldNames(column);
                        TExpressionList values = column.getExpr().getFunctionCall().getExpr1().getExprList();
                        for (int j = 0; j < fields.size(); j++) {
                                TObjectName columnName = new TObjectName();
                                columnName.setString(column.getAliasClause().getAliasName() + "." + fields.get(j));
                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel,
                                                columnName);
                                resultColumn.setStruct(true);
                                putStructField(resultColumn, new StructFieldPath(
                                                column.getAliasClause().getAliasName(),
                                                java.util.Collections.singletonList(fields.get(j)), column));
                                columnsInExpr visitor = new columnsInExpr();
                                values.getExpression(j).inOrderTraverse(visitor);
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.select);
                                }
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.select);
                                }
                                analyzeDataFlowRelation(resultColumn, visitor.getObjectNames(), EffectType.select,
                                                functions);
                                analyzeConstantDataFlowRelation(resultColumn, visitor.getConstants(),
                                                EffectType.select, functions);
                        }
                        return;
                }
                // named_struct('a', x, 'b', y) as STRUCT(x AS a, y AS b) (Mantis 4847); the positional
                // mappers pair the item, all of its fields, with one target (rule R8, Mantis 4891)
                TFunctionCall call = column.getExpr().getFunctionCall();
                boolean namedStruct = isNamedStruct(call);
                TObjectName structAlias = column.getAliasClause() != null
                                ? column.getAliasClause().getAliasName() : null;
                List<Object[]> leaves = new ArrayList<Object[]>();
                // the function node models the fields of a BigQuery STRUCT (a TTableFunction) only; Databricks
                // struct(x, y) is a STRUCT constructor of another node, whose one function column was named struct
                boolean modelledByFunction = !isPositionalStruct(call) && (call.getFunctionType() != EFunctionType.struct_t
                                || call instanceof gudusoft.gsqlparser.nodes.TTableFunction);
                if (structAlias != null && (hasNestedConstructor(call) || !modelledByFunction)
                                && constructorLeaves(call, new ArrayList<String>(), leaves)) {
                        // a STRUCT whose field is a STRUCT, or whose field names the vendor generates: a column per
                        // leaf, payload.a.b or st.col1, fed by the leaf's value (Mantis 4892)
                        for (Object[] leaf : leaves) {
                                @SuppressWarnings("unchecked")
                                List<String> path = (List<String>) leaf[0];
                                StringBuilder leafName = new StringBuilder(structAlias.toString());
                                for (String step : path) {
                                        leafName.append('.').append(step);
                                }
                                TObjectName columnName = new TObjectName();
                                columnName.setString(leafName.toString());
                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel,
                                                columnName);
                                resultColumn.setStruct(true);
                                putStructField(resultColumn, new StructFieldPath(structAlias, path, column));
                                columnsInExpr visitor = new columnsInExpr();
                                ((TExpression) leaf[1]).inOrderTraverse(visitor);
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.select);
                                }
                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.select);
                                }
                                analyzeDataFlowRelation(resultColumn, visitor.getObjectNames(), EffectType.select,
                                                functions);
                                analyzeConstantDataFlowRelation(resultColumn, visitor.getConstants(),
                                                EffectType.select, functions);
                        }
                        return;
                }
                Function function = namedStruct ? createNamedStructFunction(column.getExpr().getFunctionCall())
                                : (Function) createFunction(column.getExpr().getFunctionCall());
                String functionName = getResultSetName(function);
                for (int j = 0; j < function.getColumns().size(); j++) {
                        TObjectName columnName = new TObjectName();
                        if (column.getAliasClause() != null) {
                                columnName.setString(column.getAliasClause() + "."
                                                + function.getColumns().get(j).getName());
                        }
                        else {
                                columnName.setString(functionName + "."
                                                + function.getColumns().get(j).getName());
                        }
                        ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel,
                                        columnName);
                        resultColumn.setStruct(true);
                        if (function.getColumns().get(j).getName() != null
                                        && !function.getColumns().get(j).getName().isEmpty()) {
                                // STRUCT tree: payload.a is the field node a below the column payload, as
                                // for a ROW the query builds; BigQuery STRUCT(x AS a) AS payload too, as
                                // the plan's approved change (b) (Mantis 4847, 4834). An item without an
                                // alias names no column: its fields only pair with a column list (Mantis 4891)
                                putStructField(resultColumn, new StructFieldPath(structAlias,
                                                java.util.Collections.singletonList(function.getColumns().get(j).getName()),
                                                column));
                        }
                        DataFlowRelationship relationship = modelFactory.createDataFlowRelation();
                        relationship.setTarget(new ResultColumnRelationshipElement(resultColumn));
                        relationship.addSource(
                                        new ResultColumnRelationshipElement(function.getColumns().get(j)));
                }
        }

        /** The STRUCT fields the result columns stand for, by result column (rule R8). */
        private final Map<ResultColumn, StructFieldPath> structFieldPaths = new IdentityHashMap<ResultColumn, StructFieldPath>();

        /** The branch columns each column of a set operation reads by position, past a star of unknown width (Mantis 4914). */
        private final Map<ResultColumn, List<ResultColumn>> setColumnSources = new IdentityHashMap<ResultColumn, List<ResultColumn>>();

        /**
         * Registers the field path of a STRUCT field column; an SQL-LR recorder also learns which select item builds it
         * (observe-only: the field columns of one item are one column of the item for SQL-LR, plan 06 gate E4).
         */
        private void putStructField(ResultColumn column, StructFieldPath path) {
                structFieldPaths.put(column, path);
                SqllrObservations recorder = modelManager.getSqllrObservations();
                if (recorder != null && path != null && path.item != null) {
                        recorder.structField(column, path.item);
                }
        }

        /**
         * Trino family: the field names of a select item {@code CAST(ROW(a, b) AS ROW(city VARCHAR, phone VARCHAR)) AS
         * contact}, one per value of the row, in order; null for any other item, or when the counts differ (Mantis 4834).
         */
        private List<String> rowCastFieldNames(TResultColumn column) {
                if (column.getAliasClause() == null || column.getAliasClause().getAliasName() == null
                                || column.getExpr() == null || column.getExpr().getExpressionType() != EExpressionType.function_t) {
                        return null;
                }
                return rowCastFieldNames(column.getExpr().getFunctionCall());
        }

        /** {@link #rowCastFieldNames(TResultColumn)} of the call itself, the item aliased or not. */
        private List<String> rowCastFieldNames(TFunctionCall cast) {
                if (!nestedProfile().hasRowCastConstructor()) {
                        return null;
                }
                if (cast == null || cast.getFunctionType() != EFunctionType.cast_t || cast.getExpr1() == null
                                || cast.getExpr1().getExpressionType() != EExpressionType.row_constructor_t
                                || cast.getExpr1().getExprList() == null || cast.getTypename() == null
                                || cast.getTypename().getColumnDefList() == null) {
                        return null;
                }
                TColumnDefinitionList fields = cast.getTypename().getColumnDefList();
                if (fields.size() != cast.getExpr1().getExprList().size()) {
                        return null;
                }
                List<String> names = new ArrayList<String>();
                for (int i = 0; i < fields.size(); i++) {
                        if (fields.getColumn(i).getColumnName() == null) {
                                return null;
                        }
                        names.add(fields.getColumn(i).getColumnName().toString());
                }
                return names;
        }

        /** The field path nodes the CREATE TABLE being analyzed declares, by declared column. */
        private final Map<TableColumn, List<TableColumn>> createTableDeclaredFields =
                        new IdentityHashMap<TableColumn, List<TableColumn>>();

        /**
         * The files of an external table's LOCATION feed each field its DDL declares for {@code column}, from the same
         * field of the files' column {@code fileColumn}, as they feed the column (Mantis 4858): a read of
         * {@code payload.address.city} reaches {@code 's3://b/e/'.payload.address.city} through the table's field node.
         */
        private void linkDeclaredFieldsToFile(TableColumn column, TableColumn fileColumn, Process process) {
                // the fields this statement's DDL declares: a DROP keeps the table's model, with fields an earlier DDL declared
                List<TableColumn> declaredFields = createTableDeclaredFields.get(column);
                if (declaredFields == null) {
                        return;
                }
                for (TableColumn field : declaredFields) {
                        TableColumn fileField = modelFactory.createFileUriFieldPath(fileColumn, field.getFieldPath().getSegments());
                        if (fileField == null) {
                                continue;
                        }
                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                        relation.addSource(new TableColumnRelationshipElement(fileField));
                        relation.setTarget(new TableColumnRelationshipElement(field));
                        relation.setProcess(process);
                }
        }

        /**
         * STRUCT tree, plan section 4.2: the field path nodes of a declared column of type {@code type}, read by
         * {@link gudusoft.gsqlparser.common.structured.DeclaredTypeReader}: one per field of a STRUCT or ROW, intermediate
         * fields included; for every ARRAY a node for its element ({@code items[*]}, scalar elements too, so a LOCATION
         * feeds {@code tags[*]}, Mantis 4861); for every MAP a node for its value ({@code m[*]}) and its key
         * ({@code m[key]}), made here so a LOCATION feeds them. A field that no query reads stays a node without an edge.
         * The nodes are recorded in the nested-field declaration this CREATE TABLE opened (rule R10).
         */
        private void createStructFieldNodes(TableColumn declared, TTypeName type,
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> prefix, TObjectName position,
                        List<TableColumn> declaredFields) {
                createDeclaredNodes(declared, gudusoft.gsqlparser.common.structured.DeclaredTypeReader.read(type), prefix,
                                position, declaredFields);
        }

        private void createDeclaredNodes(TableColumn declared, gudusoft.gsqlparser.common.structured.DeclaredTypeNode type,
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> prefix, TObjectName position,
                        List<TableColumn> declaredFields) {
                if (type == null) {
                        return;
                }
                TableColumn parent = modelFactory.createDeclaredFieldPath(declared, prefix, position);
                if (parent == null) {
                        return;
                }
                parent.setDeclaredKind(type.getKind());
                switch (type.getKind()) {
                case STRUCT:
                        if (type.getFields() == null) {
                                // the grammar kept no member list: the fields are not known, none is refused
                                return;
                        }
                        for (gudusoft.gsqlparser.common.structured.DeclaredTypeNode field : type.getFields()) {
                                List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> path =
                                                new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>(prefix);
                                path.add(gudusoft.gsqlparser.common.structured.StructuredPathSegment.field(
                                                field.getFieldName().getColumnNameOnly()));
                                TableColumn node = declaredNode(declared, path, field.getFieldName(), declaredFields);
                                if (node != null) {
                                        createDeclaredNodes(declared, field, path, field.getFieldName(), declaredFields);
                                }
                        }
                        // declared once all its fields are made: a field the type does not list is not made later
                        parent.setFieldsDeclared(true);
                        break;
                case ARRAY:
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> element =
                                        new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>(prefix);
                        element.add(gudusoft.gsqlparser.common.structured.StructuredPathSegment.arrayElement());
                        if (declaredNode(declared, element, position, declaredFields) != null) {
                                createDeclaredNodes(declared, type.getElement(), element, position, declaredFields);
                        }
                        break;
                case MAP:
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> value =
                                        new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>(prefix);
                        value.add(gudusoft.gsqlparser.common.structured.StructuredPathSegment.mapValue());
                        if (declaredNode(declared, value, position, declaredFields) != null) {
                                createDeclaredNodes(declared, type.getElement(), value, position, declaredFields);
                        }
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> key =
                                        new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>(prefix);
                        key.add(gudusoft.gsqlparser.common.structured.StructuredPathSegment.mapKey());
                        if (declaredNode(declared, key, position, declaredFields) != null) {
                                createDeclaredNodes(declared, type.getKey(), key, position, declaredFields);
                        }
                        break;
                default:
                        break;
                }
        }

        /** The declared field node at {@code path}, recorded in the declaration being made and in {@code declaredFields}. */
        private TableColumn declaredNode(TableColumn declared,
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> path, TObjectName position,
                        List<TableColumn> declaredFields) {
                TableColumn node = modelFactory.createDeclaredFieldPath(declared, path, position);
                if (node != null) {
                        node.setDeclaredField(true);
                        declaredFields.add(node);
                }
                return node;
        }

        protected void flattenStructColumns(boolean hasDefinition, Table tableModel, TColumnDefinition column,
                        Stack<TColumnDefinition> columnPaths, int index) {
                columnPaths.push(column);
                for (int j = 0; j < column.getDatatype().getColumnDefList().size(); j++) {
                        TColumnDefinition columnDefinition = column.getDatatype().getColumnDefList().getColumn(j);
                        if (columnDefinition.getDatatype().getColumnDefList() != null) {
                                flattenStructColumns(hasDefinition, tableModel, columnDefinition, columnPaths, index);
                        } else {
                                TObjectName columnName = new TObjectName();
                                columnName.setString(getColumnName(columnPaths, columnDefinition));
                                TableColumn tableColumn = modelFactory.createTableColumn(tableModel, columnName, hasDefinition);
                                tableColumn.setColumnIndex(index);
                                tableColumn.setStruct(true);
                                
                                if(option.getAnalyzeMode() == AnalyzeMode.crud) {
                                        CrudRelationship crudRelationship = modelFactory.createCrudRelation();
                                        crudRelationship.setTarget(new TableColumnRelationshipElement(tableColumn));
                                        crudRelationship.setEffectType(EffectType.create_table);
                                }
                                
                                appendTableColumnToSQLEnv(tableModel, tableColumn);
                        }
                }
                columnPaths.pop();
        }

        private String getColumnName(Stack<TColumnDefinition> columnPaths, TColumnDefinition column) {
                StringBuilder buffer = new StringBuilder();
                Iterator<TColumnDefinition> iter = columnPaths.iterator();
                while(iter.hasNext()) {
                        buffer.append(iter.next().getColumnName().getColumnNameOnly()).append(".");
                }
                buffer.append(column.getColumnName().getColumnNameOnly());
                return buffer.toString();
        }

        private void appendTableColumnToSQLEnv(Table tableModel, TableColumn tableColumn) {
                //tableModel如果非determined，请不要添加到sqlenv里
                TSQLEnv targetEnv = tableMetadataEnvironment(tableModel);
                if (targetEnv != null && tableColumn!=null) {
                        TSQLSchema schema = targetEnv.getSQLSchema(DlineageUtil.getTableSchema(tableModel), true);
                        if (schema != null) {
                                TSQLTable tempTable = schema.createTable(DlineageUtil.getSimpleTableName(tableModel.getName()));
                                if (tableColumn.hasStarLinkColumn()) {
                                        for (int k = 0; k < tableColumn.starLinkCount(); k++) {
                                                tempTable.addColumn(tableColumn.starLinkCatalogSpelling(k));
                                        }
                                } else if (tableColumn.isStarColumn()) {
                                        addUnresolvedStar(tempTable);
                                } else {
                                        tempTable.addColumn(DlineageUtil.getColumnNameOnly(tableColumn.getName()));
                                }
                        }
                }
        }

        /**
         * Records in the catalog that lineage could not resolve the table's width: a star entry
         * ({@code TSQLColumn.isUnresolvedStar()}), never a column of the table. A column the catalog already holds
         * under that name is left as it is.
         */
        private static void addUnresolvedStar(TSQLTable table) {
                table.addUnresolvedStar();
        }

        private void appendTableColumnToSQLEnv(Table tableModel, TObjectName tableColumn) {
                TSQLEnv targetEnv = tableMetadataEnvironment(tableModel);
                if (targetEnv != null) {
                        TSQLSchema schema = targetEnv.getSQLSchema(DlineageUtil.getTableSchema(tableModel), true);
                        if (schema != null) {
                                TSQLTable tempTable = schema.createTable(DlineageUtil.getSimpleTableName(tableModel.getName()));
                                if (DlineageUtil.isStarName(tableColumn)) {
                                        addUnresolvedStar(tempTable);
                                } else {
                                        tempTable.addColumn(DlineageUtil.getColumnNameOnly(tableColumn.getColumnNameOnly()));
                                }
                        }
                }
        }

        private TSQLEnv tableMetadataEnvironment(Table table) {
                TTable origin = table.getTableObject();
                if (origin != null && origin.getSqlEnv() != null && ModelBindingManager.isScopedTemporary(origin)) {
                        return origin.getSqlEnv();
                }
                return sqlenv;
        }

        private void analyzeCreateStageStmt(TCreateStageStmt stmt) {
                TObjectName stageName = stmt.getStageName();

                if (stageName != null) {

                        Table tableModel = modelFactory.createStage(stageName);
                        tableModel.setCreateTable(true);
                        tableModel.setStage(true);
                        tableModel.setLocation(stmt.getExternalStageURL());

                        Process process = modelFactory.createProcess(stmt);
                        tableModel.addProcess(process);

                        TableColumn locationColumn = null;
                        if (stmt.getExternalStageURL() != null) {
                                TObjectName location = new TObjectName();
                                location.setString(stmt.getExternalStageURL());
                                locationColumn = modelFactory.createStageLocation(tableModel, location);

                                Table pathModel = modelFactory.createTableByName(stmt.getExternalStageURL(), true);
                                pathModel.setPath(true);
                                pathModel.setCreateTable(true);
                                TObjectName fileUri = new TObjectName();
                                fileUri.setString(stmt.getExternalStageURL());
                                TableColumn fileUriColumn = modelFactory.createFileUri(pathModel, fileUri);

                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                relation.setTarget(new TableColumnRelationshipElement(locationColumn));
                                relation.setProcess(process);

                        } else {
                                for (TCustomSqlStatement temp : stmt.getGsqlparser().getSqlstatements()) {
                                        if (temp instanceof TPutStmt) {
                                                TPutStmt put = (TPutStmt) temp;
                                                TStageLocation stageLocation = put.getStageLocation();
                                                if (stageLocation != null && stageLocation.getStageName() != null) {
                                                        Table stage = modelManager.getTableByName(
                                                                        DlineageUtil.getTableIdentityKey(stageLocation.getStageName().toString()));
                                                        if (stage == tableModel) {
                                                                TObjectName location = new TObjectName();
                                                                if (!SQLUtil.isEmpty(put.getFileName())) {
                                                                        location.setString(put.getFileName());
                                                                        locationColumn = modelFactory.createStageLocation(tableModel, location);
                                                                }
                                                                break;
                                                        }
                                                }
                                        }
                                }
                        }

                        String fileFormat = stmt.getFileFormatName();
                        if (fileFormat != null) {
                                for (TCustomSqlStatement temp : stmt.getGsqlparser().getSqlstatements()) {
                                        if (temp instanceof TCreateFileFormatStmt) {
                                                TCreateFileFormatStmt fileFormatStmt = (TCreateFileFormatStmt) temp;
                                                if (fileFormatStmt.getFileFormatName() != null
                                                                && SQLUtil.compareIdentifier(option.getVendor(), ESQLDataObjectType.dotTable, fileFormatStmt.getFileFormatName().toString(), fileFormat)) {
                                                        tableModel.setFileType(fileFormatStmt.getTypeName());
                                                        break;
                                                }
                                        }
                                }
                        }

                        String procedureParent = getProcedureParentName(stmt);
                        if (procedureParent != null) {
                                tableModel.setParent(procedureParent);
                        }

                        if (locationColumn != null) {
                                // A table whose LOCATION names this stage (its stage name as written, keyed like the stage).
                                Object stageKey = DlineageUtil.getTableIdentityKey(stageName.toString());
                                List<Table> tables = modelManager.getTablesByName();
                                if (tables != null) {
                                        for (Table referTable : tables) {
                                                if (referTable.getLocation() != null
                                                                && stageKey.equals(DlineageUtil.getTableIdentityKey(referTable.getLocation()))) {
                                                        for (int i = 0; i < referTable.getColumns().size(); i++) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.addSource(new TableColumnRelationshipElement(locationColumn));
                                                                relation.setTarget(new TableColumnRelationshipElement(referTable.getColumns().get(i)));
                                                        }
                                                }
                                        }
                                }
                        }
                } else {
                        ErrorInfo errorInfo = new ErrorInfo();
                        errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                        errorInfo.setErrorMessage("Can't get target table. CreateStageStmt is " + stmt.toString());
                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(stmt.getStartToken().lineNo,
                                        stmt.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(stmt.getEndToken().lineNo,
                                        stmt.getEndToken().columnNo + stmt.getEndToken().getAstext().length(),
                                        ModelBindingManager.getGlobalHash()));
                        errorInfo.fillInfo(this);
                        errorInfos.add(errorInfo);
                }
        }

        private void analyzeCreateExternalDataSourceStmt(TCreateExternalDataSourceStmt stmt) {
                TObjectName dataSourceName = stmt.getDataSourceName();
                String locationUrl = stmt.getOption("LOCATION");
                if (dataSourceName != null && locationUrl != null) {
                        Table tableModel = modelFactory.createDataSource(dataSourceName);
                        tableModel.setCreateTable(true);
                        tableModel.setDataSource(true);
                        tableModel.setLocation(locationUrl);

                        Process process = modelFactory.createProcess(stmt);
                        tableModel.addProcess(process);

                        TObjectName location = new TObjectName();
                        location.setString(locationUrl);
                        modelFactory.createTableColumn(tableModel, location, true);

                        String procedureParent = getProcedureParentName(stmt);
                        if (procedureParent != null) {
                                tableModel.setParent(procedureParent);
                        }
                } else {
                        ErrorInfo errorInfo = new ErrorInfo();
                        errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                        errorInfo.setErrorMessage("Can't get target table. CreateExternalDataSourceStmt is " + stmt.toString());
                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(stmt.getStartToken().lineNo,
                                        stmt.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(stmt.getEndToken().lineNo,
                                        stmt.getEndToken().columnNo + stmt.getEndToken().getAstext().length(),
                                        ModelBindingManager.getGlobalHash()));
                        errorInfo.fillInfo(this);
                        errorInfos.add(errorInfo);
                }
        }

        private void analyzeCreateStreamStmt(TCreateStreamStmt stmt) {
                TObjectName streamName = stmt.getStreamName();

                if (streamName != null) {
                        Table tableModel = modelFactory.createTableByName(stmt.getTableName());
                        tableModel.setCreateTable(true);

                        Table streamModel = modelFactory.createStream(streamName);
                        streamModel.setCreateTable(true);
                        streamModel.setStream(true);

                        Process process = modelFactory.createProcess(stmt);
                        tableModel.addProcess(process);

                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                        relation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(streamModel.getRelationRows()));
                        relation.addSource(new RelationRowsRelationshipElement<TableRelationRows>(tableModel.getRelationRows()));
                        relation.setProcess(process);
                }
        }

        /**
         * The routine statement a statement belongs to, found by the same walk as
         * {@link #getProcedureParentName}: the statement itself when it is a named stored procedure or function,
         * else the enclosing one, a block's owner included.
         */
        private TCustomSqlStatement getProcedureParentStatement(TCustomSqlStatement stmt) {
                if (stmt instanceof TStoredProcedureSqlStatement
                                && ((TStoredProcedureSqlStatement) stmt).getStoredProcedureName() != null) {
                        return stmt;
                }
                stmt = stmt.getParentStmt();
                if (stmt == null) {
                        return null;
                }
                if (stmt instanceof TCommonBlock
                                && ((TCommonBlock) stmt).getBlockBody().getParentObjectName() instanceof TStoredProcedureSqlStatement) {
                        stmt = (TStoredProcedureSqlStatement) ((TCommonBlock) stmt).getBlockBody().getParentObjectName();
                }
                if (stmt instanceof TStoredProcedureSqlStatement
                                && ((TStoredProcedureSqlStatement) stmt).getStoredProcedureName() != null) {
                        return stmt;
                }
                if (stmt instanceof TTeradataCreateProcedure && ((TTeradataCreateProcedure) stmt).getProcedureName() != null) {
                        return stmt;
                }
                return getProcedureParentStatement(stmt);
        }

        /**
         * The lineage model of the routine a statement belongs to, reached through that routine's own statement:
         * each routine's model is bound to its statement when it is created, and kept apart from what the
         * statement is bound to later (a SQL function's result set). Looking it up by name read a folded spelling
         * and, for an overloaded routine, took whichever overload of that name came first.
         */
        private Procedure getEnclosingProcedure(TCustomSqlStatement stmt) {
                return modelManager.getRoutineModel(getProcedureParentStatement(stmt));
        }

        /** A call's name as written with its argument-count suffix where the vendor overloads routines by count. */
        private RoutineAliasKey callAliasKey(TFunctionCall call) {
                if (call == null) return null;
                return nameAliasKey(call.getFunctionName(), RoutineAliases.callArgumentCount(call, ModelBindingManager.getGlobalVendor()));
        }

        /** A routine name as written with an alias suffix ({@code (n)}, or none). */
        private RoutineAliasKey nameAliasKey(TObjectName name, String signature) {
                return name == null ? null : RoutineAliasKey.written(name, signature);
        }

        /** The name of the routine a statement belongs to, the node getProcedureParentName reads, as written. */
        private RoutineAliasKey procedureParentAliasKey(TCustomSqlStatement stmt) {
                if (stmt == null) return null;
                TCustomSqlStatement parent = getProcedureParentStatement(stmt);
                TObjectName name = null;
                if (parent instanceof TStoredProcedureSqlStatement
                                && ((TStoredProcedureSqlStatement) parent).getStoredProcedureName() != null) {
                        name = ((TStoredProcedureSqlStatement) parent).getStoredProcedureName();
                } else if (parent instanceof TTeradataCreateProcedure) {
                        name = ((TTeradataCreateProcedure) parent).getProcedureName();
                }
                return nameAliasKey(name, null);
        }

        /** {@code key} with a single identifier as written in front (a model's schema field); null-safe. */
        private RoutineAliasKey qualifiedAliasKey(RoutineAliasKey key, String qualifier) {
                if (key == null) return null;
                try {
                        return key.withQualifier(qualifier);
                } catch (RuntimeException failure) {
                        return null;
                }
        }

        /**
         * {@code key} qualified as DlineageUtil.getTableFullNameAsWritten qualifies a name before the legacy lookup: a
         * one-level name gets the session's database and schema spellings, a two-level name its database spelling.
         */
        private RoutineAliasKey tableDefaultedAliasKey(RoutineAliasKey key) {
                if (key == null) return null;
                try {
                        String database = ModelBindingManager.getGlobalDatabaseSpelling();
                        String schema = ModelBindingManager.getGlobalSchemaSpelling();
                        if (key.size() == 1) {
                                RoutineAliasKey qualified = schema == null ? key : key.withQualifier(schema);
                                return database == null ? qualified : qualified.withQualifier(database);
                        }
                        if (key.size() == 2 && database != null) return key.withQualifier(database);
                        return key;
                } catch (RuntimeException failure) {
                        return null;
                }
        }

        /** A function result set's name as written: its function model's, or its call's. */
        private RoutineAliasKey resultSetAliasKey(ResultSet model) {
                if (model instanceof Function) return functionAliasKey((Function) model);
                if (model != null && model.getGspObject() instanceof TFunctionCall) {
                        return nameAliasKey(((TFunctionCall) model.getGspObject()).getFunctionName(), null);
                }
                return null;
        }

        /** A function model's name as written, the text getIdentifiedFunctionName reads. */
        private RoutineAliasKey functionAliasKey(Function function) {
                if (function == null) return null;
                if (function.getAliasKey() != null) return function.getAliasKey();
                TParseTreeNode object = function.getFunctionObject();
                if (object instanceof TFunctionCall) return nameAliasKey(((TFunctionCall) object).getFunctionName(), null);
                if (object instanceof TObjectName) return nameAliasKey((TObjectName) object, null);
                return null;
        }

        /** Analyzes the script's definition of the routine a call names ({@code key}), if it has one. */
        private boolean analyzeProcedureDefinition(RoutineAliasKey key) {
                TCustomSqlStatement definition = procedureDDLAliases.get(key);
                if (definition == null) return false;
                analyzeCustomSqlStmt(definition);
                return true;
        }

        /**
         * Measurement only (D3b.0, RoutineShadow): the typed routine registry's answer beside the legacy callee. Callers
         * test RoutineShadow.enabled() first, so nothing here is evaluated when it is off.
         */
        private void shadowCallee(String site, TObjectName name, Procedure callee, Integer[] aliases,
                        gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind wanted) {
                gudusoft.gsqlparser.dlineage.routine.RoutineShadow.lookedUp(modelManager, site, stmtStack.isEmpty() ? null : stmtStack.peek(), name, aliases, wanted, callee);
        }

        private String getProcedureParentName(TCustomSqlStatement stmt) {
                if (stmt instanceof TStoredProcedureSqlStatement) {
                        if (((TStoredProcedureSqlStatement) stmt).getStoredProcedureName() != null) {
                                return ((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) {
                                return ((TStoredProcedureSqlStatement) stmt).getStoredProcedureName().toString();
                        }
                }
                if (stmt instanceof TTeradataCreateProcedure) {
                        if (((TTeradataCreateProcedure) stmt).getProcedureName() != null) {
                                return ((TTeradataCreateProcedure) stmt).getProcedureName().toString();
                        }
                }

                return getProcedureParentName(stmt);
        }

        private TStoredProcedureSqlStatement getProcedureParent(TCustomSqlStatement stmt) {
                if (stmt instanceof TStoredProcedureSqlStatement) {
                        return (TStoredProcedureSqlStatement) stmt;
                }

                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) {
                        return ((TStoredProcedureSqlStatement) stmt);
                }
                if (stmt instanceof TTeradataCreateProcedure) {
                        return ((TTeradataCreateProcedure) stmt);
                }

                return getProcedureParent(stmt);
        }

        private static final class CteWriteIntent {
                private final List<TObjectName> columns = new ArrayList<TObjectName>();
                private String unsupportedReason;
        }

        private static final class CteTargetColumnMapping {
                private final String exposedName;
                private final String baseColumnName;

                private CteTargetColumnMapping(String exposedName, String baseColumnName) {
                        this.exposedName = exposedName;
                        this.baseColumnName = baseColumnName;
                }
        }

        private static final class CteWriteTargetResolution {
                private TTable baseTable;
                private final List<CteTargetColumnMapping> columns = new ArrayList<CteTargetColumnMapping>();
                private String failureReason;

                private boolean isWritable() {
                        return baseTable != null;
                }
        }

        private static final class ProjectedColumnResolution {
                private TTable baseTable;
                private String baseColumnName;
                private String failureReason;
        }

        private static final class CteSelectRelationKey {
                private final ResultColumn target;
                private final ResultColumn source;

                private CteSelectRelationKey(ResultColumn target, ResultColumn source) {
                        this.target = target;
                        this.source = source;
                }

                @Override
                public int hashCode() {
                        return 31 * System.identityHashCode(target) + System.identityHashCode(source);
                }

                @Override
                public boolean equals(Object other) {
                        if (!(other instanceof CteSelectRelationKey)) {
                                return false;
                        }
                        CteSelectRelationKey key = (CteSelectRelationKey) other;
                        return target == key.target && source == key.source;
                }
        }

        private CteWriteIntent collectMergeCteWriteIntent(TMergeSqlStatement stmt, TTable targetTable) {
                CteWriteIntent intent = new CteWriteIntent();
                if (stmt.getWhenClauses() == null) {
                        intent.unsupportedReason = "the MERGE has no writable target columns";
                        return intent;
                }
                for (int i = 0; i < stmt.getWhenClauses().size(); i++) {
                        TMergeWhenClause clause = stmt.getWhenClauses().getElement(i);
                        if (clause.getUpdateClause() != null) {
                                TResultColumnList assignments = clause.getUpdateClause().getUpdateColumnList();
                                if (assignments != null) {
                                        for (int j = 0; j < assignments.size(); j++) {
                                                TExpression assignment = assignments.getResultColumn(j).getExpr();
                                                addCteWriteIntentTargets(intent, assignment == null ? null : assignment.getLeftOperand());
                                        }
                                }
                        }
                        if (clause.getInsertClause() != null) {
                                if (clause.getInsertClause().getInsertValue() != null) {
                                        addCteWriteIntentWarning(intent,
                                                        "an object-constructor INSERT target cannot be mapped to CTE projections");
                                        continue;
                                }
                                TObjectNameList columns = clause.getInsertClause().getColumnList();
                                if (columns == null || columns.size() == 0) {
                                        List<TObjectName> inferredColumns = inferProjectedInsertColumns(targetTable,
                                                        clause.getInsertClause().getValuelist());
                                        if (inferredColumns == null) {
                                                addCteWriteIntentWarning(intent,
                                                                "an INSERT without an explicit target column list cannot be mapped safely");
                                                continue;
                                        }
                                        for (TObjectName inferredColumn : inferredColumns) {
                                                addCteWriteIntentColumn(intent, inferredColumn);
                                        }
                                        continue;
                                }
                                for (int j = 0; j < columns.size(); j++) {
                                        addCteWriteIntentColumn(intent, columns.getObjectName(j));
                                }
                        }
                }
                if (intent.columns.isEmpty() && intent.unsupportedReason == null) {
                        intent.unsupportedReason = "the MERGE has no modified columns from which to resolve a base table";
                }
                return intent;
        }

        private void addCteWriteIntentWarning(CteWriteIntent intent, String reason) {
                if (intent.unsupportedReason == null) {
                        intent.unsupportedReason = reason;
                } else if (!intent.unsupportedReason.contains(reason)) {
                        intent.unsupportedReason += "; " + reason;
                }
        }

        private List<TObjectName> inferProjectedInsertColumns(TTable targetTable, TResultColumnList values) {
                if (targetTable == null || values == null) {
                        return null;
                }
                TSelectSqlStatement subquery = null;
                TObjectNameList exposedColumns = null;
                if (targetTable.getCTE() != null) {
                        subquery = targetTable.getCTE().getSubquery();
                        exposedColumns = targetTable.getCTE().getColumnList();
                } else if (targetTable.getSubquery() != null) {
                        subquery = targetTable.getSubquery();
                        exposedColumns = getProjectedTargetColumns(targetTable);
                } else if (targetTable.getLinkTable() != null
                                && targetTable.getLinkTable().getSubquery() != null) {
                        subquery = targetTable.getLinkTable().getSubquery();
                        exposedColumns = getProjectedTargetColumns(targetTable.getLinkTable());
                }
                TResultColumnList projections = subquery == null ? null : subquery.getResultColumnList();
                if (projections == null || projections.size() != values.size()) {
                        return null;
                }
                if (exposedColumns != null && exposedColumns.size() > 0
                                && exposedColumns.size() != projections.size()) {
                        return null;
                }
                List<TObjectName> inferredColumns = new ArrayList<TObjectName>();
                for (int i = 0; i < projections.size(); i++) {
                        TResultColumn projection = projections.getResultColumn(i);
                        if (isCteStarProjection(projection)) {
                                return null;
                        }
                        String exposedName = getProjectedColumnName(exposedColumns, projection, i);
                        if (SQLUtil.isEmpty(exposedName)) {
                                return null;
                        }
                        TObjectName column = new TObjectName();
                        TSourceToken nameToken = new TSourceToken(exposedName);
                        TResultColumn value = values.getResultColumn(i);
                        column.setPartToken(nameToken);
                        column.setObjectType(TObjectName.ttobjColumn);
                        column.setSourceTable(targetTable);
                        column.setStartToken(value.getStartToken() == null
                                        ? nameToken : value.getStartToken());
                        column.setEndToken(value.getEndToken() == null
                                        ? nameToken : value.getEndToken());
                        inferredColumns.add(column);
                }
                return inferredColumns;
        }

        private CteWriteIntent collectUpdateCteWriteIntent(TUpdateSqlStatement stmt) {
                CteWriteIntent intent = new CteWriteIntent();
                TResultColumnList assignments = stmt.getResultColumnList();
                if (assignments == null) {
                        intent.unsupportedReason = "the UPDATE has no writable target columns";
                        return intent;
                }
                for (int i = 0; i < assignments.size(); i++) {
                        TExpression assignment = assignments.getResultColumn(i).getExpr();
                        if (assignment == null || assignment.getExpressionType() == EExpressionType.function_t) {
                                addCteWriteIntentWarning(intent,
                                                "an UPDATE assignment target cannot be mapped to a CTE projection");
                                continue;
                        }
                        addCteWriteIntentTargets(intent, assignment.getLeftOperand());
                }
                if (intent.columns.isEmpty() && intent.unsupportedReason == null) {
                        intent.unsupportedReason = "the UPDATE has no modified columns from which to resolve a base table";
                }
                return intent;
        }

        /** The target of an UPDATE SET assignment under any parentheses: SET (t.col) = (...) writes t.col (Mantis 4984). */
        private static TExpression updateSetTarget(TExpression target) {
                while (target != null && target.getExpressionType() == EExpressionType.parenthesis_t) {
                        target = target.getLeftOperand();
                }
                return target;
        }

        /**
         * The {@code count} items of a row value, (x, y) or ROW(x, y), also inside grouping parentheses such as
         * (ROW(x, y)), or null when the value is no row of that many items.
         */
        private static TExpressionList rowValues(TExpression value, int count) {
                value = updateSetTarget(value);
                while (value != null && (value.getExpressionType() == EExpressionType.list_t
                                || value.getExpressionType() == EExpressionType.row_constructor_t) && value.getExprList() != null) {
                        if (value.getExprList().size() == count) {
                                return value.getExprList();
                        }
                        if (value.getExprList().size() != 1) {
                                return null;
                        }
                        value = updateSetTarget(value.getExprList().getExpression(0));
                }
                return null;
        }

        /** The columns an UPDATE SET assignment target names, for mapping a CTE or inline view target to its base table. */
        private void addCteWriteIntentTargets(CteWriteIntent intent, TExpression target) {
                target = updateSetTarget(target);
                if (target != null && target.getExpressionType() == EExpressionType.simple_object_name_t) {
                        addCteWriteIntentColumn(intent, target.getObjectOperand());
                } else if (target != null && target.getExpressionType() == EExpressionType.list_t
                                && target.getExprList() != null) {
                        for (int j = 0; j < target.getExprList().size(); j++) {
                                TExpression item = target.getExprList().getExpression(j);
                                if (item.getExpressionType() == EExpressionType.simple_object_name_t) {
                                        addCteWriteIntentColumn(intent, item.getObjectOperand());
                                } else {
                                        addCteWriteIntentWarning(intent,
                                                        "an UPDATE assignment target cannot be mapped to a CTE projection");
                                }
                        }
                } else {
                        addCteWriteIntentWarning(intent, "an UPDATE assignment target cannot be mapped to a CTE projection");
                }
        }

        /** Reports an UPDATE SET assignment that is left out of the lineage, at its target, else at the assignment. */
        private void addUnanalyzedSetAssignmentError(String reason, TExpression target, TExpression assignment) {
                TExpression at = target != null && target.getStartToken() != null && target.getEndToken() != null ? target
                                : assignment;
                ErrorInfo errorInfo = new ErrorInfo();
                errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                errorInfo.setErrorMessage(reason + ", the assignment is not analyzed: " + at.toString());
                errorInfo.setStartPosition(new Pair3<Long, Long, String>(at.getStartToken().lineNo,
                                at.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                errorInfo.setEndPosition(new Pair3<Long, Long, String>(at.getEndToken().lineNo,
                                at.getEndToken().columnNo + at.getEndToken().getAstext().length(), ModelBindingManager.getGlobalHash()));
                errorInfo.fillInfo(this);
                errorInfos.add(errorInfo);
        }

        /** A MERGE UPDATE SET target that is a variable, not a column of the target table. */
        private boolean isMergeUpdateVariable(TObjectName columnObject) {
                if (columnObject.getDbObjectType() == EDbObjectType.variable) {
                        return true;
                }
                if (columnObject.getColumnNameOnly().startsWith("@")
                                && (option.getVendor() == EDbVendor.dbvmssql || option.getVendor() == EDbVendor.dbvazuresql)) {
                        return true;
                }
                return columnObject.getColumnNameOnly().startsWith(":")
                                && (option.getVendor() == EDbVendor.dbvhana || option.getVendor() == EDbVendor.dbvteradata);
        }

        /** MERGE ... UPDATE SET column = value: the MERGE-UPDATE column takes the value and writes the target column. */
        private void analyzeMergeUpdateColumn(TObjectName columnObject, TExpression valueExpression, ResultSet resultSet,
                        Object tableModel, CteWriteTargetResolution cteTargetResolution, Process process) {
                if (isMergeUpdateVariable(columnObject)) {
                        return;
                }

                ResultColumn updateColumn = modelFactory.createMergeResultColumn(resultSet, columnObject);

                if (valueExpression == null)
                        return;

                columnsInExpr visitor = new columnsInExpr();
                valueExpression.inOrderTraverse(visitor);
                List<TObjectName> objectNames = visitor.getObjectNames();
                List<TParseTreeNode> functions = visitor.getFunctions();

                if (functions != null && !functions.isEmpty()) {
                        analyzeFunctionDataFlowRelation(updateColumn, functions, EffectType.merge_update);
                }

                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                if (subquerys != null && !subquerys.isEmpty()) {
                        analyzeSubqueryDataFlowRelation(updateColumn, subquerys, EffectType.merge_update);
                }

                analyzeDataFlowRelation(updateColumn, objectNames, EffectType.merge_update, functions);

                List<TParseTreeNode> constants = visitor.getConstants();
                analyzeConstantDataFlowRelation(updateColumn, constants, EffectType.merge_update, functions);

                writeMergeUpdateColumn(columnObject, updateColumn, tableModel, cteTargetResolution, process);
        }

        private void writeMergeUpdateColumn(TObjectName columnObject, ResultColumn updateColumn, Object tableModel,
                        CteWriteTargetResolution cteTargetResolution, Process process) {
                if (tableModel instanceof Table) {
                        TObjectName targetColumn = getCteBaseColumn(cteTargetResolution, columnObject);
                        TableColumn tableColumn = targetColumn == null ? null
                                        : modelFactory.createTableColumn((Table) tableModel, targetColumn, false);

                        if (tableColumn != null) {
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.merge_update);
                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                relation.addSource(new ResultColumnRelationshipElement(updateColumn));
                                relation.setProcess(process);
                        }
                }
        }

        /**
         * MERGE ... UPDATE SET (a, b) = (SELECT x, y ...) or (x, y), also ROW(x, y): each column takes the value at its
         * position (Mantis 4986). A subquery whose select list has a star or another length cannot be paired by position, so
         * the assignment is reported instead of guessed.
         */
        private void analyzeMergeUpdateColumnList(TExpression assignment, TExpression targetList, ResultSet resultSet,
                        Object tableModel, CteWriteTargetResolution cteTargetResolution, Process process) {
                TExpressionList targets = targetList.getExprList();
                TExpression value = assignment.getRightOperand();
                if (targets == null || value == null) {
                        addUnanalyzedSetAssignmentError("Unsupported UPDATE SET target", targetList, assignment);
                        return;
                }
                for (int k = 0; k < targets.size(); k++) {
                        if (targets.getExpression(k).getExpressionType() != EExpressionType.simple_object_name_t) {
                                addUnanalyzedSetAssignmentError("Unsupported UPDATE SET target", targetList, assignment);
                                return;
                        }
                }

                TSelectSqlStatement query = value.getSubQuery();
                if (query != null) {
                        analyzeSelectStmt(query);
                        ResultSet sourceModel = (ResultSet) modelManager.getModel(query);
                        List<ResultColumn> sourceColumns = sourceModel == null ? null : sourceModel.getColumns();
                        boolean pairable = sourceColumns != null && sourceColumns.size() == targets.size();
                        for (int k = 0; pairable && k < sourceColumns.size(); k++) {
                                pairable = !isStarNode(sourceColumns.get(k).getColumnObject());
                        }
                        if (!pairable) {
                                addUnanalyzedSetAssignmentError("UPDATE SET columns do not pair with the subquery's select list",
                                                targetList, assignment);
                                return;
                        }
                        for (int k = 0; k < targets.size(); k++) {
                                TObjectName columnObject = targets.getExpression(k).getObjectOperand();
                                if (isMergeUpdateVariable(columnObject)) {
                                        continue;
                                }
                                ResultColumn updateColumn = modelFactory.createMergeResultColumn(resultSet, columnObject);
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.merge_update);
                                relation.setTarget(new ResultColumnRelationshipElement(updateColumn));
                                relation.addSource(new ResultColumnRelationshipElement(sourceColumns.get(k)));
                                writeMergeUpdateColumn(columnObject, updateColumn, tableModel, cteTargetResolution, process);
                        }
                        // the rows the subquery picks decide the values, as for SET column = (subquery)
                        if (!sourceModel.getRelationRows().getHoldRelations().isEmpty()) {
                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                impactRelation.setEffectType(EffectType.select);
                                impactRelation.addSource(
                                                new RelationRowsRelationshipElement<ResultSetRelationRows>(sourceModel.getRelationRows()));
                                impactRelation.setTarget(
                                                new RelationRowsRelationshipElement<ResultSetRelationRows>(resultSet.getRelationRows()));
                        }
                } else if (rowValues(value, targets.size()) != null) {
                        TExpressionList values = rowValues(value, targets.size());
                        for (int k = 0; k < targets.size(); k++) {
                                analyzeMergeUpdateColumn(targets.getExpression(k).getObjectOperand(), values.getExpression(k),
                                                resultSet, tableModel, cteTargetResolution, process);
                        }
                } else {
                        addUnanalyzedSetAssignmentError("UPDATE SET columns do not pair with the assigned value", targetList,
                                        assignment);
                }
        }

        private void addCteWriteIntentColumn(CteWriteIntent intent, TObjectName column) {
                if (column == null || column.getDbObjectType() == EDbObjectType.variable) {
                        return;
                }
                String name = column.getColumnNameOnly();
                if (name == null) {
                        return;
                }
                if (name.startsWith("@") && (option.getVendor() == EDbVendor.dbvmssql
                                || option.getVendor() == EDbVendor.dbvazuresql)) {
                        return;
                }
                if (name.startsWith(":") && (option.getVendor() == EDbVendor.dbvhana
                                || option.getVendor() == EDbVendor.dbvteradata)) {
                        return;
                }
                intent.columns.add(column);
        }

        private CteWriteTargetResolution resolveCteWriteTarget(TTable targetTable, CteWriteIntent intent) {
                TSelectSqlStatement subquery = targetTable == null || targetTable.getCTE() == null
                                ? null : targetTable.getCTE().getSubquery();
                TObjectNameList exposedColumns = targetTable == null || targetTable.getCTE() == null
                                ? null : targetTable.getCTE().getColumnList();
                return resolveProjectedWriteTarget(subquery, exposedColumns, intent);
        }

        private CteWriteTargetResolution resolveProjectedWriteTarget(TSelectSqlStatement subquery,
                        TObjectNameList exposedColumns, CteWriteIntent intent) {
                CteWriteTargetResolution resolution = new CteWriteTargetResolution();
                if (intent.unsupportedReason != null) {
                        appendCteResolutionWarning(resolution, intent.unsupportedReason);
                }
                if (subquery == null) {
                        appendCteResolutionWarning(resolution, "the target CTE has no SELECT body");
                        return resolution;
                }

                if (subquery.isCombinedQuery() || subquery.getSetOperatorType() != ESetOperatorType.none) {
                        appendCteResolutionWarning(resolution,
                                        "a CTE with a set operator is not a writable single-table projection");
                        return resolution;
                }
                if (subquery.getSelectDistinct() != null && !subquery.getSelectDistinct().isAll()) {
                        appendCteResolutionWarning(resolution,
                                        "a DISTINCT CTE is not a writable single-table projection");
                        return resolution;
                }
                if (hasCteAggregate(subquery)) {
                        appendCteResolutionWarning(resolution,
                                        "a grouped or aggregate CTE is not a writable single-table projection");
                        return resolution;
                }
                TResultColumnList projections = subquery.getResultColumnList();
                if (projections == null || projections.size() == 0) {
                        appendCteResolutionWarning(resolution, "the target CTE has no selectable columns");
                        return resolution;
                }

                for (TObjectName modifiedColumn : intent.columns) {
                        int projectionIndex = findCteProjectionIndex(exposedColumns, modifiedColumn, projections);
                        if (projectionIndex < 0) {
                                appendCteResolutionWarning(resolution, "modified column '" + modifiedColumn.getColumnNameOnly()
                                                + "' does not map uniquely to a CTE projection");
                                continue;
                        }
                        TResultColumn projection = projections.getResultColumn(projectionIndex);
                        boolean starProjection = isCteStarProjection(projection);
                        if (starProjection && exposedColumns != null && exposedColumns.size() > 0) {
                                appendCteResolutionWarning(resolution, "modified column '" + modifiedColumn.getColumnNameOnly()
                                                + "' cannot be mapped safely through an explicitly named wildcard projection");
                                continue;
                        }
                        TObjectName projectedColumn = projection.getColumnFullname();
                        if (starProjection && projectedColumn != null
                                        && SQLUtil.isEmpty(projectedColumn.getTableString())
                                        && subquery.tables != null && subquery.tables.size() > 1) {
                                appendCteResolutionWarning(resolution,
                                                "an unqualified wildcard over multiple tables is ambiguous");
                                continue;
                        }
                        if (projectedColumn == null || projectedColumn.getColumnSource() == null) {
                                appendCteResolutionWarning(resolution, "modified column '" + modifiedColumn.getColumnNameOnly()
                                                + "' is calculated or has no resolvable base column");
                                continue;
                        }

                        gudusoft.gsqlparser.resolver2.model.ColumnSource source = projectedColumn.getColumnSource();
                        if (!starProjection && SQLUtil.isEmpty(projectedColumn.getTableString())
                                        && isAmbiguousUnqualifiedProjection(subquery, projectedColumn)) {
                                appendCteResolutionWarning(resolution,
                                                "an unqualified projection over multiple tables is ambiguous");
                                continue;
                        }
                        if (source.isAmbiguous()) {
                                appendCteResolutionWarning(resolution, "modified column '" + modifiedColumn.getColumnNameOnly()
                                                + "' has more than one possible base table");
                                continue;
                        }
                        String projectedColumnName = starProjection
                                        ? modifiedColumn.getColumnNameOnly() : projectedColumn.getColumnNameOnly();
                        ProjectedColumnResolution projectedResolution = resolveProjectedColumn(
                                        getResolvedProjectedSourceTable(projectedColumn), projectedColumnName,
                                        new HashSet<TSelectSqlStatement>());
                        if (projectedResolution.failureReason != null) {
                                appendCteResolutionWarning(resolution, projectedResolution.failureReason);
                                continue;
                        }
                        TTable baseTable = projectedResolution.baseTable;
                        if (!isPhysicalCteWriteTable(baseTable)) {
                                appendCteResolutionWarning(resolution, "modified column '" + modifiedColumn.getColumnNameOnly()
                                                + "' does not resolve to a physical base table");
                                continue;
                        }
                        if (resolution.baseTable != null && resolution.baseTable != baseTable) {
                                appendCteResolutionWarning(resolution,
                                                "modified columns resolve to more than one base table");
                                resolution.baseTable = null;
                                resolution.columns.clear();
                                return resolution;
                        }

                        String baseColumnName = projectedResolution.baseColumnName;
                        if (SQLUtil.isEmpty(baseColumnName)) {
                                baseColumnName = projectedColumn.getColumnNameOnly();
                        }
                        if (SQLUtil.isEmpty(baseColumnName)) {
                                appendCteResolutionWarning(resolution, "modified column '" + modifiedColumn.getColumnNameOnly()
                                                + "' has no resolvable physical column name");
                                continue;
                        }

                        resolution.baseTable = baseTable;
                        resolution.columns.add(new CteTargetColumnMapping(modifiedColumn.getColumnNameOnly(), baseColumnName));
                }
                if (resolution.baseTable == null && resolution.failureReason == null) {
                        resolution.failureReason = "no modified column resolves safely to a physical base table";
                }
                return resolution;
        }

        private boolean isAmbiguousUnqualifiedProjection(TSelectSqlStatement subquery,
                        TObjectName projectedColumn) {
                if (subquery.tables == null || subquery.tables.size() <= 1) {
                        return false;
                }
                String columnName = projectedColumn.getColumnNameOnly();
                int matches = 0;
                int unknowns = 0;
                TTable onlyUnknown = null;
                for (int i = 0; i < subquery.tables.size(); i++) {
                        TTable candidate = subquery.tables.getTable(i);
                        Boolean hasColumn = hasAuthoritativeColumn(candidate, columnName);
                        if (hasColumn == null) {
                                unknowns++;
                                onlyUnknown = candidate;
                                continue;
                        }
                        if (hasColumn.booleanValue() && ++matches > 1) {
                                return true;
                        }
                }
                if (matches == 1) {
                        return unknowns != 0;
                }
                return unknowns != 1 || getResolvedProjectedSourceTable(projectedColumn) != onlyUnknown;
        }

        private TTable getResolvedProjectedSourceTable(TObjectName column) {
                if (column == null) {
                        return null;
                }
                TTable sourceTable = column.getSourceTable();
                if (sourceTable != null || column.getColumnSource() == null
                                || column.getColumnSource().getSourceNamespace() == null) {
                        return sourceTable;
                }
                return column.getColumnSource().getSourceNamespace().getSourceTable();
        }

        private Boolean hasAuthoritativeColumn(TTable table, String columnName) {
                if (table == null || SQLUtil.isEmpty(columnName)) {
                        return null;
                }
                if (!isPhysicalCteWriteTable(table)) {
                        TSelectSqlStatement subquery = null;
                        TObjectNameList exposedColumns = null;
                        if (table.getCTE() != null) {
                                subquery = table.getCTE().getSubquery();
                                exposedColumns = table.getCTE().getColumnList();
                        } else if (table.getSubquery() != null) {
                                subquery = table.getSubquery();
                                exposedColumns = getProjectedTargetColumns(table);
                        } else if (table.getLinkTable() != null
                                        && table.getLinkTable().getSubquery() != null) {
                                subquery = table.getLinkTable().getSubquery();
                                exposedColumns = getProjectedTargetColumns(table.getLinkTable());
                        }
                        TResultColumnList projections = subquery == null
                                        ? null : subquery.getResultColumnList();
                        if (projections == null || projections.size() == 0
                                        || (exposedColumns != null && exposedColumns.size() > 0
                                                        && exposedColumns.size() != projections.size())) {
                                return null;
                        }
                        boolean matched = false;
                        for (int i = 0; i < projections.size(); i++) {
                                TResultColumn projection = projections.getResultColumn(i);
                                if (isCteStarProjection(projection)) {
                                        return null;
                                }
                                String exposedName = getProjectedColumnName(exposedColumns, projection, i);
                                if (SQLUtil.isEmpty(exposedName)) {
                                        return null;
                                }
                                if (SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn,
                                                columnName, exposedName)) {
                                        matched = true;
                                }
                        }
                        return Boolean.valueOf(matched);
                }
                TColumnDefinitionList definitions = table.getColumnDefinitions();
                if (definitions != null && definitions.size() > 0) {
                        for (int i = 0; i < definitions.size(); i++) {
                                TObjectName name = definitions.getColumn(i).getColumnName();
                                if (name != null && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn,
                                                columnName, name.getColumnNameOnly())) {
                                        return Boolean.TRUE;
                                }
                        }
                        return Boolean.FALSE;
                }
                if (sqlenv == null || table.getTableName() == null) {
                        return null;
                }
                TSQLTable sqlTable = sqlenv.searchTable(table.getTableName());
                if (sqlTable == null || sqlTable.getColumnList() == null
                                || sqlTable.getColumnList().isEmpty()) {
                        return null;
                }
                for (TSQLColumn column : sqlTable.getColumnList()) {
                        if (sqlenv.getIdentifierService().canonKeyOf(columnName, ESQLDataObjectType.dotColumn,
                    gudusoft.gsqlparser.sqlenv.IdentifierInputForm.SQL_LEXICAL).equals(
                    sqlenv.getIdentifierService().canonKeyOf(column.getName(), ESQLDataObjectType.dotColumn,
                    gudusoft.gsqlparser.sqlenv.IdentifierInputForm.CATALOG_STORED))) {
                                return Boolean.TRUE;
                        }
                }
                return Boolean.FALSE;
        }

        private ProjectedColumnResolution resolveProjectedColumn(TTable sourceTable, String columnName,
                        Set<TSelectSqlStatement> visited) {
                ProjectedColumnResolution resolution = new ProjectedColumnResolution();
                if (sourceTable == null) {
                        resolution.failureReason = "a projected column has no uniquely resolved source table";
                        return resolution;
                }
                if (isPhysicalCteWriteTable(sourceTable)) {
                        resolution.baseTable = sourceTable;
                        resolution.baseColumnName = columnName;
                        return resolution;
                }
                TSelectSqlStatement subquery = null;
                TObjectNameList exposedColumns = null;
                if (sourceTable.getCTE() != null) {
                        subquery = sourceTable.getCTE().getSubquery();
                        exposedColumns = sourceTable.getCTE().getColumnList();
                } else if (sourceTable.getSubquery() != null) {
                        subquery = sourceTable.getSubquery();
                        exposedColumns = getProjectedTargetColumns(sourceTable);
                } else if (sourceTable.getLinkTable() != null
                                && sourceTable.getLinkTable().getSubquery() != null) {
                        subquery = sourceTable.getLinkTable().getSubquery();
                        exposedColumns = getProjectedTargetColumns(sourceTable.getLinkTable());
                }
                if (subquery == null || !visited.add(subquery)) {
                        resolution.failureReason = subquery == null
                                        ? "an intermediate projection has no SELECT body"
                                        : "the projected target contains a cyclic intermediate query";
                        return resolution;
                }
                if (subquery.isCombinedQuery() || subquery.getSetOperatorType() != ESetOperatorType.none) {
                        resolution.failureReason = "an intermediate projection with a set operator is not writable";
                        return resolution;
                }
                if (subquery.getSelectDistinct() != null && !subquery.getSelectDistinct().isAll()) {
                        resolution.failureReason = "an intermediate DISTINCT projection is not writable";
                        return resolution;
                }
                if (hasCteAggregate(subquery)) {
                        resolution.failureReason = "an intermediate grouped or aggregate projection is not writable";
                        return resolution;
                }
                TResultColumnList projections = subquery.getResultColumnList();
                if (projections == null || projections.size() == 0 || SQLUtil.isEmpty(columnName)) {
                        resolution.failureReason = "an intermediate projection has no mappable target column";
                        return resolution;
                }
                TObjectName exposedColumn = new TObjectName();
                TSourceToken columnToken = new TSourceToken(columnName);
                exposedColumn.setPartToken(columnToken);
                exposedColumn.setObjectType(TObjectName.ttobjColumn);
                int projectionIndex = findCteProjectionIndex(exposedColumns, exposedColumn, projections);
                if (projectionIndex < 0) {
                        resolution.failureReason = "modified column '" + columnName
                                        + "' does not map uniquely through an intermediate projection";
                        return resolution;
                }
                TResultColumn projection = projections.getResultColumn(projectionIndex);
                boolean starProjection = isCteStarProjection(projection);
                if (starProjection && exposedColumns != null && exposedColumns.size() > 0) {
                        resolution.failureReason = "modified column '" + columnName
                                        + "' cannot be mapped safely through an explicitly named intermediate wildcard projection";
                        return resolution;
                }
                TObjectName innerColumn = projection.getColumnFullname();
                if (innerColumn == null || innerColumn.getColumnSource() == null) {
                        resolution.failureReason = "modified column '" + columnName
                                        + "' has no resolvable intermediate base column";
                        return resolution;
                }
                if (starProjection && SQLUtil.isEmpty(innerColumn.getTableString())
                                && subquery.tables != null && subquery.tables.size() > 1) {
                        resolution.failureReason = "an unqualified intermediate wildcard over multiple tables is ambiguous";
                        return resolution;
                }
                gudusoft.gsqlparser.resolver2.model.ColumnSource source = innerColumn.getColumnSource();
                if (!starProjection && SQLUtil.isEmpty(innerColumn.getTableString())
                                && isAmbiguousUnqualifiedProjection(subquery, innerColumn)) {
                        resolution.failureReason = "an unqualified intermediate projection over multiple tables is ambiguous";
                        return resolution;
                }
                if (source.isAmbiguous()) {
                        resolution.failureReason = "modified column '" + columnName
                                        + "' has more than one possible intermediate base table";
                        return resolution;
                }
                String innerName = starProjection ? columnName : innerColumn.getColumnNameOnly();
                return resolveProjectedColumn(getResolvedProjectedSourceTable(innerColumn), innerName, visited);
        }

        private void appendCteResolutionWarning(CteWriteTargetResolution resolution, String reason) {
                if (resolution.failureReason == null) {
                        resolution.failureReason = reason;
                } else if (!resolution.failureReason.contains(reason)) {
                        resolution.failureReason += "; " + reason;
                }
        }

        private boolean hasCteAggregate(TSelectSqlStatement subquery) {
                if (subquery.getGroupByClause() != null) {
                        return true;
                }
                TResultColumnList projections = subquery.getResultColumnList();
                if (projections == null) {
                        return false;
                }
                for (int i = 0; i < projections.size(); i++) {
                        TExpression expression = projections.getResultColumn(i).getExpr();
                        if (expression == null) {
                                continue;
                        }
                        columnsInExpr visitor = new columnsInExpr();
                        expression.inOrderTraverse(visitor);
                        List<TParseTreeNode> functions = visitor.getFunctions();
                        if (functions == null) {
                                continue;
                        }
                        for (TParseTreeNode function : functions) {
                                if (function instanceof TFunctionCall
                                                && ((TFunctionCall) function).getWindowDef() == null
                                                && isAggregateFunction((TFunctionCall) function)) {
                                        return true;
                                }
                        }
                }
                return false;
        }

        private int findCteProjectionIndex(TObjectNameList exposedColumns, TObjectName modifiedColumn,
                        TResultColumnList projections) {
                int match = -1;
                int starMatch = -1;
                for (int i = 0; i < projections.size(); i++) {
                        TResultColumn projection = projections.getResultColumn(i);
                        String exposedName;
                        if (exposedColumns != null && exposedColumns.size() > 0) {
                                if (i >= exposedColumns.size()) {
                                        continue;
                                }
                                exposedName = getProjectedColumnName(exposedColumns, projection, i);
                        } else {
                                exposedName = SQLUtil.isEmpty(projection.getColumnAlias())
                                                ? projection.getDisplayName() : projection.getColumnAlias();
                                if (isCteStarProjection(projection)) {
                                        if (starMatch == -1) {
                                                starMatch = i;
                                        } else {
                                                starMatch = -2;
                                        }
                                }
                        }
                        if (SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn,
                                        modifiedColumn.getColumnNameOnly(), exposedName)) {
                                if (match >= 0) {
                                        return -1;
                                }
                                match = i;
                        }
                }
                return match >= 0 ? match : starMatch;
        }

        private String getProjectedColumnName(TObjectNameList exposedColumns,
                        TResultColumn projection, int index) {
                if (exposedColumns != null && exposedColumns.size() > 0) {
                        if (index >= exposedColumns.size()) {
                                return null;
                        }
                        TObjectName exposedColumn = exposedColumns.getObjectName(index);
                        String exposedName = exposedColumn.getColumnNameOnly();
                        return SQLUtil.isEmpty(exposedName) ? exposedColumn.toString() : exposedName;
                }
                return SQLUtil.isEmpty(projection.getColumnAlias())
                                ? projection.getDisplayName() : projection.getColumnAlias();
        }

        private boolean isCteStarProjection(TResultColumn projection) {
                if (projection == null || projection.getExpr() == null
                                || projection.getExpr().getExpressionType() != EExpressionType.simple_object_name_t
                                || projection.getExpr().getObjectOperand() == null) {
                        return false;
                }
                return DlineageUtil.isWildcard(projection.getExpr().getObjectOperand());
        }

        private boolean isPhysicalCteWriteTable(TTable table) {
                return table != null && table.getTableName() != null && table.getCTE() == null
                                && table.getSubquery() == null
                                && (table.getLinkTable() == null || table.getLinkTable().getSubquery() == null);
        }

        private CteWriteTargetResolution resolveCteDeleteTarget(TSelectSqlStatement subquery) {
                return resolveCteDeleteTarget(subquery, new HashSet<TSelectSqlStatement>());
        }

        private CteWriteTargetResolution resolveCteDeleteTarget(TSelectSqlStatement subquery,
                        Set<TSelectSqlStatement> visited) {
                CteWriteTargetResolution resolution = new CteWriteTargetResolution();
                if (subquery == null || !visited.add(subquery)) {
                        resolution.failureReason = "the target CTE has no acyclic SELECT body";
                        return resolution;
                }
                if (subquery.isCombinedQuery() || subquery.getSetOperatorType() != ESetOperatorType.none) {
                        resolution.failureReason = "a CTE with a set operator is not a writable single-table projection";
                        return resolution;
                }
                if (subquery.getSelectDistinct() != null && !subquery.getSelectDistinct().isAll()) {
                        resolution.failureReason = "a DISTINCT CTE is not a writable single-table projection";
                        return resolution;
                }
                if (hasCteAggregate(subquery)) {
                        resolution.failureReason = "a grouped or aggregate CTE is not a writable single-table projection";
                        return resolution;
                }
                if (subquery.tables == null || subquery.tables.size() != 1) {
                        resolution.failureReason = "a DELETE target CTE resolves to more than one base table";
                        return resolution;
                }
                TTable table = subquery.tables.getTable(0);
                if (isPhysicalCteWriteTable(table)) {
                        resolution.baseTable = table;
                        return resolution;
                }
                if (table.getCTE() != null) {
                        return resolveCteDeleteTarget(table.getCTE().getSubquery(), visited);
                }
                if (table.getSubquery() != null) {
                        return resolveCteDeleteTarget(table.getSubquery(), visited);
                }
                if (table.getLinkTable() != null && table.getLinkTable().getSubquery() != null) {
                        return resolveCteDeleteTarget(table.getLinkTable().getSubquery(), visited);
                }
                resolution.failureReason = "the DELETE target CTE does not resolve to a physical base table";
                return resolution;
        }

        private TObjectNameList getProjectedTargetColumns(TTable targetTable) {
                return targetTable.getAliasClause() == null
                                ? null : targetTable.getAliasClause().getColumns();
        }

        private TObjectName getCteBaseColumn(CteWriteTargetResolution resolution, TObjectName targetColumn) {
                if (resolution == null) {
                        return targetColumn;
                }
                if (!resolution.isWritable() || targetColumn == null) {
                        return null;
                }
                for (CteTargetColumnMapping mapping : resolution.columns) {
                        if (SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn,
                                        targetColumn.getColumnNameOnly(), mapping.exposedName)) {
                                TObjectName baseColumn = new TObjectName();
                                TSourceToken nameToken = new TSourceToken(mapping.baseColumnName);
                                baseColumn.setPartToken(nameToken);
                                baseColumn.setObjectType(TObjectName.ttobjColumn);
                                baseColumn.setSourceTable(resolution.baseTable);
                                baseColumn.setStartToken(targetColumn.getStartToken() == null
                                                ? nameToken : targetColumn.getStartToken());
                                baseColumn.setEndToken(targetColumn.getEndToken() == null
                                                ? nameToken : targetColumn.getEndToken());
                                return baseColumn;
                        }
                }
                return null;
        }

        private QueryTable analyzeCteWriteTarget(TTable targetTable, Process process) {
                return analyzeProjectedWriteTarget(targetTable, targetTable.getCTE().getSubquery(),
                                targetTable.getCTE().getColumnList(), process);
        }

        private QueryTable analyzeProjectedWriteTarget(TTable targetTable, TSelectSqlStatement subquery,
                        TObjectNameList exposedColumns, Process process) {
                QueryTable queryTable = modelFactory.createQueryTable(targetTable);
                if (exposedColumns != null) {
                        for (int i = 0; i < exposedColumns.size(); i++) {
                                modelFactory.createResultColumn(queryTable, exposedColumns.getObjectName(i));
                        }
                }

                if (subquery == null || stmtStack.contains(subquery)) {
                        return queryTable;
                }
                analyzeSelectStmt(subquery);
                ResultSet resultSetModel = (ResultSet) modelManager.getModel(subquery);
                if (resultSetModel == null || resultSetModel == queryTable) {
                        return queryTable;
                }

                if (!resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                        impactRelation.setEffectType(EffectType.select);
                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                        resultSetModel.getRelationRows()));
                        impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                        queryTable.getRelationRows()));
                }

                if (subquery.getSetOperatorType() != ESetOperatorType.none) {
                        SelectSetResultSet selectSetResultSetModel = (SelectSetResultSet) resultSetModel;
                        for (int i = 0; i < selectSetResultSetModel.getColumns().size(); i++) {
                                ResultColumn sourceColumn = selectSetResultSetModel.getColumns().get(i);
                                ResultColumn targetColumn = exposedColumns != null && i < queryTable.getColumns().size()
                                                ? queryTable.getColumns().get(i)
                                                : modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                        targetColumn.bindStarLinkColumn(starLinkColumn);
                                }
                                createCteSelectRelation(process, targetColumn, sourceColumn);
                        }
                } else {
                        for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                ResultColumn sourceColumn = resultSetModel.getColumns().get(i);
                                ResultColumn targetColumn = exposedColumns != null && i < queryTable.getColumns().size()
                                                ? queryTable.getColumns().get(i)
                                                : modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                        targetColumn.bindStarLinkColumn(starLinkColumn);
                                }
                                createCteSelectRelation(process, targetColumn, sourceColumn);
                        }
                }
                return queryTable;
        }

        private void createProjectedWriteImpact(TSelectSqlStatement subquery, Table tableModel,
                        EffectType effectType, Process process) {
                if (subquery == null || tableModel == null) {
                        return;
                }
                Object model = modelManager.getModel(subquery);
                if (!(model instanceof ResultSet)) {
                        return;
                }
                ResultSet resultSet = (ResultSet) model;
                if (resultSet.getRelationRows().getHoldRelations().isEmpty()) {
                        return;
                }
                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                impactRelation.setEffectType(effectType);
                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                resultSet.getRelationRows()));
                impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                tableModel.getRelationRows()));
                impactRelation.setProcess(process);
        }

        private void createCteSelectRelation(Process process, ResultColumn targetColumn, ResultColumn sourceColumn) {
                createCteSelectRelation(process, targetColumn, sourceColumn, false);
        }

        /** {@code positional}: the target is a position of a column list, which reads a star whole ({@link #positionSource}). */
        private void createCteSelectRelation(Process process, ResultColumn targetColumn, ResultColumn sourceColumn,
                        boolean positional) {
                if (!cteSelectRelationKeys.add(new CteSelectRelationKey(targetColumn, sourceColumn))) {
                        return;
                }
                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(EffectType.select);
                relation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                relation.addSource(positional ? positionSource(sourceColumn) : new ResultColumnRelationshipElement(sourceColumn));
                relation.setProcess(process);
        }

        private void addCteWriteTargetHint(TTable targetTable, String reason) {
                addCteWriteTargetHint(targetTable, reason, false);
        }

        private void addCteWriteTargetHint(TTable targetTable, String reason, boolean partiallyResolved) {
                ErrorInfo errorInfo = new ErrorInfo();
                errorInfo.setErrorType(ErrorInfo.SYNTAX_HINT);
                String targetKind = targetTable.getCTE() == null ? "Projected write target" : "CTE write target";
                String targetName = targetTable.getTableName() == null
                                ? targetTable.getAliasName() : targetTable.getTableName().toString();
                errorInfo.setErrorMessage(targetKind + " '" + targetName + "' "
                                + (partiallyResolved ? "was only partially resolved: " : "was kept as a result set: ")
                                + reason + ".");
                if (targetTable.getStartToken() != null && targetTable.getEndToken() != null) {
                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(targetTable.getStartToken().lineNo,
                                        targetTable.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(targetTable.getEndToken().lineNo,
                                        targetTable.getEndToken().columnNo
                                                        + targetTable.getEndToken().getAstext().length(), ModelBindingManager.getGlobalHash()));
                }
                errorInfo.fillInfo(this);
                errorInfos.add(errorInfo);
        }

        private void analyzeMergeStmt(TMergeSqlStatement stmt) {
                Object tableModel;
                CteWriteTargetResolution cteTargetResolution = null;
                // the source result set whose rows a branch below already carried to the target
                ResultSet sourceRowsLinked = null;
                // the relations made for the ON and WHEN conditions
                List<ImpactRelationship> conditionRelations = new ArrayList<ImpactRelationship>();
                // the result sets of the UPDATE and INSERT actions, with their effect
                List<Pair<ResultSet, EffectType>> actionRows = new ArrayList<Pair<ResultSet, EffectType>>();
                if (stmt.getUsingTable() != null) {
                        TTable table = stmt.getTargetTable();
                        Process process = modelFactory.createProcess(stmt);
                        if (table.getCTE() != null) {
                                QueryTable cteTargetModel = analyzeCteWriteTarget(table, process);
                                cteTargetResolution = resolveCteWriteTarget(table, collectMergeCteWriteIntent(stmt, table));
                                if (cteTargetResolution.isWritable()) {
                                        tableModel = modelFactory.createTable(cteTargetResolution.baseTable);
                                        ((Table) tableModel).addProcess(process);
                                        createProjectedWriteImpact(table.getCTE().getSubquery(), (Table) tableModel,
                                                        EffectType.merge, process);
                                } else {
                                        tableModel = cteTargetModel;
                                }
                                if (cteTargetResolution.failureReason != null) {
                                        addCteWriteTargetHint(table, cteTargetResolution.failureReason,
                                                        cteTargetResolution.isWritable());
                                }
                        } else if(table.getSubquery()!=null) {
                                TObjectNameList exposedColumns = getProjectedTargetColumns(table);
                                QueryTable projectedTargetModel = analyzeProjectedWriteTarget(table,
                                                table.getSubquery(), exposedColumns, process);
                                cteTargetResolution = resolveProjectedWriteTarget(table.getSubquery(), exposedColumns,
                                                collectMergeCteWriteIntent(stmt, table));
                                if (cteTargetResolution.isWritable()) {
                                        tableModel = modelFactory.createTable(cteTargetResolution.baseTable);
                                        ((Table) tableModel).addProcess(process);
                                        createProjectedWriteImpact(table.getSubquery(), (Table) tableModel,
                                                        EffectType.merge, process);
                                } else {
                                        tableModel = projectedTargetModel;
                                }
                                if (cteTargetResolution.failureReason != null) {
                                        addCteWriteTargetHint(table, cteTargetResolution.failureReason,
                                                        cteTargetResolution.isWritable());
                                }
                        }
                        else {
                                tableModel = modelFactory.createTable(table);
                                ((Table)tableModel).addProcess(process);
                        }
                        
                        for(TTable item: stmt.tables) {
                                // Skip subqueries and CTE references: a CTE feeding USING is resolved
                                // through its subquery (see the getCTE() branch below), so materializing
                                // it here as a physical base table leaves a spurious table named after
                                // the CTE in the lineage output. (MantisBT #4493)
                                if(item.getSubquery()!=null || item.getCTE()!=null) {
                                        continue;
                                }
                                Table tableItemModel = modelFactory.createTable(item);                          
                                if (tableItemModel.getColumns() == null || tableItemModel.getColumns().isEmpty()) {
                                        tableItemModel.addColumnsFromSQLEnv();
                                }
                        }

                        if (stmt.getUsingTable().getSubquery() != null) {
                                QueryTable queryTable = modelFactory.createQueryTable(stmt.getUsingTable());
                                analyzeSelectStmt(stmt.getUsingTable().getSubquery());

                                ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt.getUsingTable().getSubquery());
                                
                                if (queryTable != null && resultSetModel != null && queryTable != resultSetModel) {
                                        if (queryTable.getColumns().size() == resultSetModel.getColumns().size()) {
                                                for (int i = 0; i < queryTable.getColumns().size(); i++) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.select);
                                                        relation.setTarget(new ResultColumnRelationshipElement(queryTable.getColumns().get(i)));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultSetModel.getColumns().get(i)));
                                                        relation.setProcess(process);
                                                }
                                        }
                                }
                                
                                if (resultSetModel != null && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.setEffectType(EffectType.merge);
                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        resultSetModel.getRelationRows()));
                                        if (tableModel instanceof Table) {
                                                impactRelation.setTarget(
                                                                new RelationRowsRelationshipElement<TableRelationRows>(((Table)tableModel).getRelationRows()));
                                        }
                                        else {
                                                impactRelation.setTarget(
                                                                new RelationRowsRelationshipElement<ResultSetRelationRows>(((ResultSet)tableModel).getRelationRows()));
                                        }
                                        sourceRowsLinked = resultSetModel;
                                }
                        } else if (stmt.getUsingTable().getCTE() != null) {
                                // USING references a CTE defined in the WITH clause attached to the
                                // MERGE. Mirror the SELECT-side CTE handling so the CTE subquery (and
                                // the base tables inside it) are analyzed and linked through to the
                                // merge source; otherwise the CTE is treated as an opaque base table
                                // and the tables feeding it are dropped from the lineage. (MantisBT #4493)
                                QueryTable queryTable = modelFactory.createQueryTable(stmt.getUsingTable());

                                TObjectNameList cteColumns = stmt.getUsingTable().getCTE().getColumnList();
                                if (cteColumns != null) {
                                        for (int j = 0; j < cteColumns.size(); j++) {
                                                modelFactory.createResultColumn(queryTable, cteColumns.getObjectName(j));
                                        }
                                }

                                TSelectSqlStatement subquery = stmt.getUsingTable().getCTE().getSubquery();
                                if (subquery != null && !stmtStack.contains(subquery)) {
                                        analyzeSelectStmt(subquery);

                                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(subquery);

                                        if (resultSetModel != null && resultSetModel != queryTable) {
                                                if (subquery.getSetOperatorType() != ESetOperatorType.none) {
                                                        SelectSetResultSet selectSetResultSetModel = (SelectSetResultSet) modelManager
                                                                        .getModel(subquery);
                                                        for (int j = 0; j < selectSetResultSetModel.getColumns().size(); j++) {
                                                                ResultColumn sourceColumn = selectSetResultSetModel.getColumns().get(j);
                                                                ResultColumn targetColumn = null;
                                                                if (cteColumns != null && j < queryTable.getColumns().size()) {
                                                                        targetColumn = queryTable.getColumns().get(j);
                                                                } else {
                                                                        targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                                                }
                                                                for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                        targetColumn.bindStarLinkColumn(starLinkColumn);
                                                                }
                                                                createCteSelectRelation(process, targetColumn, sourceColumn);
                                                        }
                                                } else {
                                                        for (int j = 0; j < resultSetModel.getColumns().size(); j++) {
                                                                ResultColumn sourceColumn = resultSetModel.getColumns().get(j);
                                                                ResultColumn targetColumn = null;
                                                                if (cteColumns != null && j < queryTable.getColumns().size()) {
                                                                        targetColumn = queryTable.getColumns().get(j);
                                                                } else {
                                                                        targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                                                }
                                                                for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                        targetColumn.bindStarLinkColumn(starLinkColumn);
                                                                }
                                                                createCteSelectRelation(process, targetColumn, sourceColumn);
                                                        }
                                                }
                                        }

                                        if (resultSetModel != null && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(EffectType.merge);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                resultSetModel.getRelationRows()));
                                                if (tableModel instanceof Table) {
                                                        impactRelation.setTarget(
                                                                        new RelationRowsRelationshipElement<TableRelationRows>(((Table) tableModel).getRelationRows()));
                                                } else {
                                                        impactRelation.setTarget(
                                                                        new RelationRowsRelationshipElement<ResultSetRelationRows>(((ResultSet) tableModel).getRelationRows()));
                                                }
                                                sourceRowsLinked = resultSetModel;
                                        }
                                }
                        } else {
                                if (stmt.getUsingTable().getAliasClause() != null && stmt.getUsingTable().getAliasClause().getColumns() != null && stmt.getUsingTable().getValueClause() != null && stmt.getUsingTable().getValueClause().getRows()!=null) {
                                        Table usingTable = modelFactory.createTableFromCreateDDL(stmt.getUsingTable(), false, stmt.getUsingTable().getAliasName() + stmt.getUsingTable().getTableName());
                                        usingTable.setCreateTable(true);
                                        usingTable.setSubType(SubType.function);
                                        for (int z=0;z<stmt.getUsingTable().getAliasClause().getColumns().size();z++) {
                                                TObjectName columnName = stmt.getUsingTable().getAliasClause().getColumns().getObjectName(z);
                                                TableColumn tableColumn = modelFactory.createTableColumn(usingTable, columnName, true);
                                                TResultColumn resultColumn = stmt.getUsingTable().getValueClause().getRows().get(0).getResultColumn(z);
                                                modelManager.bindModel(resultColumn, tableColumn);
                                                analyzeResultColumnExpressionRelation(tableColumn, resultColumn.getExpr());                                             }
                                }
                                else {
                                        Table sourceTable = modelFactory.createTable(stmt.getUsingTable());
                                        // A source table whose rows were picked by a filter or a join (#t filled by
                                        // SELECT ... INTO ... WHERE) passes that on to the target, as a filtered subquery
                                        // source does above (MantisBT #4758)
                                        if (sourceTable != tableModel && !sourceTable.getRelationRows().getHoldRelations().isEmpty()) {
                                                createMergeRowsImpact(
                                                                new RelationRowsRelationshipElement<TableRelationRows>(sourceTable.getRelationRows()),
                                                                tableModel);
                                        }
                                }
                        }


                        if (stmt.getWhenClauses() != null && stmt.getWhenClauses().size() > 0) {
                                for (int i = 0; i < stmt.getWhenClauses().size(); i++) {
                                        TMergeWhenClause clause = stmt.getWhenClauses().getElement(i);
                                        if (clause.getCondition() != null) {
                                                conditionRelations.add(
                                                                analyzeFilterCondition(null, clause.getCondition(), null, null, EffectType.merge_when));
                                        }
                                        // the predicates of the action pick its rows as a WHEN condition does: Oracle's
                                        // UPDATE ... WHERE, DELETE WHERE and INSERT ... WHERE, and a DELETE's own condition
                                        for (TExpression predicate : mergeActionPredicates(clause)) {
                                                conditionRelations.add(analyzeFilterCondition(null, predicate, null, null, EffectType.merge_when));
                                        }
                                        if (clause.getUpdateClause() != null) {
                                                TResultColumnList columns = clause.getUpdateClause().getUpdateColumnList();
                                                if (columns == null || columns.size() == 0)
                                                        continue;

                                                ResultSet resultSet = modelFactory.createResultSet(clause.getUpdateClause(), false);
                                                createPseudoImpactRelation(stmt, resultSet, EffectType.merge_update);
                                                actionRows.add(new Pair<ResultSet, EffectType>(resultSet, EffectType.merge_update));

                                                for (int j = 0; j < columns.size(); j++) {
                                                        TExpression assignment = columns.getResultColumn(j).getExpr();
                                                        TExpression assignmentTarget = updateSetTarget(assignment.getLeftOperand());
                                                        if (assignmentTarget != null
                                                                        && assignmentTarget.getExpressionType() == EExpressionType.simple_object_name_t) {
                                                                analyzeMergeUpdateColumn(assignmentTarget.getObjectOperand(), assignment.getRightOperand(),
                                                                                resultSet, tableModel, cteTargetResolution, process);
                                                        } else if (assignmentTarget != null
                                                                        && assignmentTarget.getExpressionType() == EExpressionType.list_t) {
                                                                analyzeMergeUpdateColumnList(assignment, assignmentTarget, resultSet, tableModel,
                                                                                cteTargetResolution, process);
                                                        } else {
                                                                addUnanalyzedSetAssignmentError("Unsupported UPDATE SET target", assignmentTarget, assignment);
                                                        }
                                                }
                                        }
                                        if (clause.getInsertClause() != null) {
                                                TExpression insertValue = clause.getInsertClause().getInsertValue();
                                                if (insertValue != null
                                                                && insertValue.getExpressionType() == EExpressionType.objectConstruct_t) {
                                                        ResultSet resultSet = modelFactory.createResultSet(clause.getInsertClause(), false);

                                                        createPseudoImpactRelation(stmt, resultSet, EffectType.merge_insert);
                                                        actionRows.add(new Pair<ResultSet, EffectType>(resultSet, EffectType.merge_insert));

                                                        TObjectConstruct objectConstruct = insertValue.getObjectConstruct();
                                                        for (int z = 0; z < objectConstruct.getPairs().size(); z++) {
                                                                TPair pair = objectConstruct.getPairs().getElement(z);

                                                                if (pair.getKeyName().getExpressionType() == EExpressionType.simple_constant_t) {
                                                                        TObjectName columnObject = new TObjectName();
                                                                        TConstant constant = pair.getKeyName().getConstantOperand();
                                                                        TSourceToken newSt = new TSourceToken(
                                                                                        constant.getValueToken().getTextWithoutQuoted());
                                                                        columnObject.setPartToken(newSt);
                                                                        columnObject.setSourceTable(stmt.getTargetTable());
                                                                        columnObject.setStartToken(constant.getStartToken());
                                                                        columnObject.setEndToken(constant.getEndToken());

                                                                        ResultColumn insertColumn = modelFactory.createMergeResultColumn(resultSet,
                                                                                        columnObject);

                                                                        TExpression valueExpression = pair.getKeyValue();
                                                                        if (valueExpression == null)
                                                                                continue;

                                                                        columnsInExpr visitor = new columnsInExpr();
                                                                        valueExpression.inOrderTraverse(visitor);
                                                                        List<TObjectName> objectNames = visitor.getObjectNames();
                                                                        List<TParseTreeNode> functions = visitor.getFunctions();

                                                                        if (functions != null && !functions.isEmpty()) {
                                                                                analyzeFunctionDataFlowRelation(insertColumn, functions,
                                                                                                EffectType.merge_insert);
                                                                        }

                                                                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                                                        if (subquerys != null && !subquerys.isEmpty()) {
                                                                                analyzeSubqueryDataFlowRelation(insertColumn, subquerys,
                                                                                                EffectType.merge_insert);
                                                                        }

                                                                        analyzeDataFlowRelation(insertColumn, objectNames, EffectType.merge_insert,
                                                                                        functions);

                                                                        List<TParseTreeNode> constants = visitor.getConstants();
                                                                        analyzeConstantDataFlowRelation(insertColumn, constants, EffectType.merge_insert,
                                                                                        functions);

                                                                        TObjectName targetColumn = getCteBaseColumn(cteTargetResolution, columnObject);
                                                                        TableColumn tableColumn = !(tableModel instanceof Table) || targetColumn == null ? null
                                                                                        : modelFactory.createTableColumn((Table)tableModel, targetColumn, false);

                                                                        if (tableColumn != null) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.merge_insert);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(insertColumn));
                                                                                relation.setProcess(process);
                                                                        }
                                                                }
                                                        }
                                                } else {
                                                        TObjectNameList columns = clause.getInsertClause().getColumnList();
                                                        TResultColumnList values = clause.getInsertClause().getValuelist();
                                                        if (values == null || values.size() == 0) {
                                                                if (clause.getInsertClause().toString().toLowerCase(Locale.ROOT).indexOf("row") != -1) {
                                                                        if (stmt.getUsingTable().getSubquery() != null && tableModel instanceof Table) {
                                                                                ResultSet sourceResultSet = modelFactory.createQueryTable(stmt.getUsingTable());
                                                                                TObjectName targetStarColumn = DlineageUtil.syntheticStarName();
                                                                                TableColumn targetTableColumn = modelFactory.createTableColumn((Table)tableModel,
                                                                                                targetStarColumn, true);
                                                                                if (sourceResultSet.getColumns() == null
                                                                                                || sourceResultSet.getColumns().isEmpty()) {
                                                                                        TObjectName sourceStarColumn = DlineageUtil.syntheticStarName();
                                                                                        modelFactory.createResultColumn(sourceResultSet, sourceStarColumn);
                                                                                }
                                                                                for (ResultColumn sourceColumn : sourceResultSet.getColumns()) {
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.merge_insert);
                                                                                        relation.setTarget(new TableColumnRelationshipElement(targetTableColumn));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                                                                        relation.setProcess(process);
                                                                                }
                                                                        } else if (tableModel instanceof Table) {
                                                                                Table sourceTable = modelFactory.createTable(stmt.getUsingTable());
                                                                                TObjectName sourceStarColumn = DlineageUtil.syntheticStarName();
                                                                                TableColumn sourceTableColumn = modelFactory.createTableColumn(sourceTable,
                                                                                                sourceStarColumn, true);
                                                                                TObjectName targetStarColumn = DlineageUtil.syntheticStarName();
                                                                                TableColumn targetTableColumn = modelFactory.createTableColumn(((Table)tableModel),
                                                                                                targetStarColumn, true);
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.merge_insert);
                                                                                relation.setTarget(new TableColumnRelationshipElement(targetTableColumn));
                                                                                relation.addSource(new TableColumnRelationshipElement(sourceTableColumn));
                                                                                relation.setProcess(process);
                                                                        }

                                                                }
                                                                continue;
                                                        }

                                                        List<TObjectName> tableColumns = new ArrayList<TObjectName>();
                                                        boolean unresolvedProjectedColumns = false;
                                                        if (columns == null || columns.size() == 0) {
                                                                List<TObjectName> inferredColumns = inferProjectedInsertColumns(
                                                                                stmt.getTargetTable(), values);
                                                                unresolvedProjectedColumns = inferredColumns == null
                                                                                && cteTargetResolution != null;
                                                                if (inferredColumns != null) {
                                                                        tableColumns.addAll(inferredColumns);
                                                                } else {
//                                                              if (!((Table)tableModel).getColumns().isEmpty()) {
//                                                                      for (int j = 0; j < ((Table)tableModel).getColumns().size(); j++) {
//                                                                              if (((Table)tableModel).getColumns().get(j).getColumnObject() == null) {
//                                                                                      continue;
//                                                                              }
//                                                                              tableColumns.add(((Table)tableModel).getColumns().get(j).getColumnObject());
//                                                                      }
//                                                              } else {
                                                                        for (int j = 0; j < values.size(); j++) {
                                                                                TResultColumn column = values.getResultColumn(j);
                                                                                if (column.getAliasClause() != null) {
                                                                                        tableColumns.add(column.getAliasClause().getAliasName());
                                                                                } else if (column.getFieldAttr() != null) {
                                                                                        tableColumns.add(column.getFieldAttr());
                                                                                } else {
                                                                                        TObjectName columnName = new TObjectName();
                                                                                        columnName.setString(column.toString());
                                                                                        tableColumns.add(columnName);
                                                                                }
//                                                                      }
                                                                        }
                                                                }
                                                        } else {
                                                                for (int j = 0; j < columns.size(); j++) {
                                                                        tableColumns.add(columns.getObjectName(j));
                                                                }
                                                        }

                                                        ResultSet resultSet = modelFactory.createResultSet(clause.getInsertClause(), false);

                                                        createPseudoImpactRelation(stmt, resultSet, EffectType.merge_insert);
                                                        actionRows.add(new Pair<ResultSet, EffectType>(resultSet, EffectType.merge_insert));

                                                        for (int j = 0; j < tableColumns.size() && j < values.size(); j++) {
                                                                TObjectName columnObject = tableColumns.get(j);

                                                                ResultColumn insertColumn = modelFactory.createMergeResultColumn(resultSet,
                                                                                columnObject);

                                                                TExpression valueExpression = values.getResultColumn(j).getExpr();
                                                                if (valueExpression == null)
                                                                        continue;

                                                                columnsInExpr visitor = new columnsInExpr();
                                                                valueExpression.inOrderTraverse(visitor);
                                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                                List<TParseTreeNode> functions = visitor.getFunctions();

                                                                if (functions != null && !functions.isEmpty()) {
                                                                        analyzeFunctionDataFlowRelation(insertColumn, functions, EffectType.merge_insert);
                                                                }

                                                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                                                if (subquerys != null && !subquerys.isEmpty()) {
                                                                        analyzeSubqueryDataFlowRelation(insertColumn, subquerys, EffectType.merge_insert);
                                                                }

                                                                analyzeDataFlowRelation(insertColumn, objectNames, EffectType.merge_insert, functions);

                                                                List<TParseTreeNode> constants = visitor.getConstants();
                                                                analyzeConstantDataFlowRelation(insertColumn, constants, EffectType.merge_insert,
                                                                                functions);

                                                                TObjectName targetColumn = unresolvedProjectedColumns ? null
                                                                                : getCteBaseColumn(cteTargetResolution, columnObject);
                                                                TableColumn tableColumn = !(tableModel instanceof Table) || targetColumn == null ? null
                                                                                : modelFactory.createTableColumn(((Table)tableModel), targetColumn, false);
                                                                if(tableColumn == null) {
                                                                        if (cteTargetResolution == null && tableModel instanceof Table
                                                                                        && ((Table) tableModel).isCreateTable()) {
                                                                                tableColumn = ((Table) tableModel).getColumns().get(j);
                                                                        }
                                                                        else {
                                                                                continue;
                                                                        }
                                                                }

                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.merge_insert);
                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(insertColumn));
                                                                relation.setProcess(process);
                                                        }
                                                }
                                        }
                                }

                        }

                        if (stmt.getCondition() != null) {
                                conditionRelations.add(
                                                analyzeFilterCondition(null, stmt.getCondition(), null, JoinClauseType.on, EffectType.merge));
                        }
                        // The ON and WHEN conditions decide which target rows are matched and which source rows are
                        // inserted. analyzeFilterCondition records them on the source's rows; carry those rows to the
                        // target unless a branch above already did. A table, VALUES or CTE source, or a subquery
                        // without a filter of its own, left them without an edge, so the condition columns reached
                        // no table (MantisBT #4758).
                        Set<ResultSet> conditionRowsLinked = Collections.newSetFromMap(new IdentityHashMap<ResultSet, Boolean>());
                        for (ImpactRelationship condition : conditionRelations) {
                                if (condition == null || condition.getTarget() == null
                                                || !(condition.getTarget().getElement() instanceof ResultSetRelationRows)) {
                                        continue;
                                }
                                ResultSet conditionRows = ((ResultSetRelationRows) condition.getTarget().getElement()).getHolder();
                                if (conditionRows == null || conditionRows == tableModel || !conditionRowsLinked.add(conditionRows)) {
                                        continue;
                                }
                                if (conditionRows != sourceRowsLinked) {
                                        createMergeRowsImpact(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        conditionRows.getRelationRows()), tableModel);
                                }
                                // the same rows pick the rows each action updates or inserts; a filtered source reached
                                // them through createPseudoImpactRelation already, an unfiltered one did not
                                for (Pair<ResultSet, EffectType> action : actionRows) {
                                        if (action.first != conditionRows && !hasRowsEdge(conditionRows, action.first)) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(action.second);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                conditionRows.getRelationRows()));
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                action.first.getRelationRows()));
                                        }
                                }
                        }
                }
        }

        /** Oracle's UPDATE ... WHERE, DELETE WHERE and INSERT ... WHERE of a MERGE branch, and a DELETE's own condition. */
        private static List<TExpression> mergeActionPredicates(TMergeWhenClause clause) {
                List<TExpression> predicates = new ArrayList<TExpression>();
                if (clause.getUpdateClause() != null) {
                        if (clause.getUpdateClause().getUpdateWhereClause() != null) {
                                predicates.add(clause.getUpdateClause().getUpdateWhereClause());
                        }
                        if (clause.getUpdateClause().getDeleteWhereClause() != null) {
                                predicates.add(clause.getUpdateClause().getDeleteWhereClause());
                        }
                }
                if (clause.getInsertClause() != null && clause.getInsertClause().getInsertWhereClause() != null) {
                        predicates.add(clause.getInsertClause().getInsertWhereClause());
                }
                if (clause.getDeleteClause() != null && clause.getDeleteClause().getCondition() != null) {
                        predicates.add(clause.getDeleteClause().getCondition());
                }
                return predicates;
        }

        /** Whether a row-level relation already runs from {@code from}'s rows to {@code to}'s rows. */
        private static boolean hasRowsEdge(ResultSet from, ResultSet to) {
                for (Relationship relation : to.getRelationRows().getHoldRelations()) {
                        for (Object source : relation.getSources()) {
                                if (source instanceof RelationshipElement
                                                && ((RelationshipElement<?>) source).getElement() == from.getRelationRows()) {
                                        return true;
                                }
                        }
                }
                return false;
        }

        /** A merge impact from {@code sourceRows} to the rows of the MERGE target (a table, or a query table). */
        private void createMergeRowsImpact(RelationRowsRelationshipElement<?> sourceRows, Object targetModel) {
                RelationRowsRelationshipElement<?> targetRows;
                if (targetModel instanceof Table) {
                        targetRows = new RelationRowsRelationshipElement<TableRelationRows>(((Table) targetModel).getRelationRows());
                } else if (targetModel instanceof ResultSet) {
                        targetRows = new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                        ((ResultSet) targetModel).getRelationRows());
                } else {
                        return;
                }
                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                impactRelation.setEffectType(EffectType.merge);
                impactRelation.addSource(sourceRows);
                impactRelation.setTarget(targetRows);
        }

        private List<TableColumn> bindInsertTableColumn(Table tableModel, TInsertIntoValue value, List<TObjectName> keyMap,
                        List<TResultColumn> valueMap) {
                List<TableColumn> tableColumns = new ArrayList<TableColumn>();
                if (value.getColumnList() != null) {
                        for (int z = 0; z < value.getColumnList().size(); z++) {
                                TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                value.getColumnList().getObjectName(z));
                                tableColumns.add(tableColumn);
                                keyMap.add(tableColumn.getColumnObject());
                        }
                }

                if (value.getTargetList() != null) {
                        for (int z = 0; z < value.getTargetList().size(); z++) {
                                TMultiTarget target = value.getTargetList().getMultiTarget(z);
                                TResultColumnList columns = target.getColumnList();
                                for (int i = 0; i < columns.size(); i++) {
                                        if (value.getColumnList() == null) {
                                                TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                columns.getResultColumn(i).getFieldAttr());
                                                tableColumns.add(tableColumn);
                                        }
                                        valueMap.add(columns.getResultColumn(i));
                                }
                        }
                }

                return tableColumns;
        }

        /**
         * Whether an INTO clause of a multi-table INSERT (Oracle {@code INSERT ALL} / {@code INSERT FIRST}) decides its
         * own mapping, with a column list or a VALUES clause. One with neither takes the subquery's columns in order,
         * as {@code INSERT INTO t SELECT ...} does.
         */
        private static boolean mapsItsOwnColumns(TInsertIntoValue value) {
                return (value.getColumnList() != null && value.getColumnList().size() > 0) || insertIntoValues(value) != null;
        }

        /** The VALUES items of an INTO clause of a multi-table INSERT, or null when it has no VALUES clause. */
        private static TResultColumnList insertIntoValues(TInsertIntoValue value) {
                if (value.getTargetList() == null || value.getTargetList().size() == 0) {
                        return null;
                }
                TMultiTarget row = value.getTargetList().getMultiTarget(0);
                return row == null || row.getColumnList() == null || row.getColumnList().size() == 0 ? null
                                : row.getColumnList();
        }

        /** An INTO clause of a multi-table INSERT that names its own columns or values, with its target columns. */
        private static final class SelfMappedInto {
                final Table table;
                final TInsertIntoValue value;
                /** the target column of each position of the clause, null where no column can be named */
                final List<TableColumn> targets;
                /** the clause's position among the statement's INTO clauses */
                final int position;
                /** the WHEN conditions that decide which rows reach the clause, see {@link #governingConditions} */
                final List<TExpression> conditions;

                SelfMappedInto(Table table, TInsertIntoValue value, List<TableColumn> targets, int position,
                                List<TExpression> conditions) {
                        this.table = table;
                        this.value = value;
                        this.targets = targets;
                        this.position = position;
                        this.conditions = conditions;
                }
        }

        /** The columns one INTO clause of a conditional multi-table INSERT writes, and the WHEN conditions routing rows to it. */
        private static final class WhenScope {
                final int position;
                final List<TableColumn> targets;
                final List<TExpression> conditions;

                WhenScope(int position, List<TableColumn> targets, List<TExpression> conditions) {
                        this.position = position;
                        this.targets = targets;
                        this.conditions = conditions;
                }
        }

        /**
         * The WHEN conditions that decide which rows reach the INTO clauses of the {@code branch}-th WHEN of a
         * conditional multi-table INSERT, or of its ELSE when {@code branch} is the number of WHENs. INSERT ALL tests
         * every WHEN on its own, so a branch depends on its own condition; INSERT FIRST takes the first WHEN that holds,
         * so a branch depends on its own condition and every one before it; ELSE takes the rows no WHEN took, so it
         * depends on all of them. The rows of a branch did not use to be tied to its own condition: every condition was
         * applied to every target, and a target of a clause without a column list or VALUES got none.
         */
        private static List<TExpression> governingConditions(TInsertSqlStatement stmt, int branch) {
                List<TExpression> conditions = new ArrayList<TExpression>();
                int count = stmt.getInsertConditions().size();
                for (int i = 0; i < count; i++) {
                        TExpression condition = stmt.getInsertConditions().getElement(i).getCondition();
                        if (condition == null) {
                                continue;
                        }
                        if (i == branch || branch >= count || (stmt.isInsertFirst() && i < branch)) {
                                conditions.add(condition);
                        }
                }
                return conditions;
        }

        /** The relations registered so far, by identity, to tell afterwards which ones a step added. */
        private Set<Relationship> relationSnapshot() {
                Set<Relationship> snapshot = Collections.newSetFromMap(new IdentityHashMap<Relationship, Boolean>());
                snapshot.addAll(Arrays.asList(modelManager.getRelations()));
                return snapshot;
        }

        /** The columns of {@code table} that value relations registered after {@code snapshot} write into. */
        private List<TableColumn> columnsWrittenSince(Set<Relationship> snapshot, Table table) {
                List<TableColumn> written = new ArrayList<TableColumn>();
                for (Relationship relation : modelManager.getRelations()) {
                        if (snapshot.contains(relation) || !(relation instanceof DataFlowRelationship)
                                        || !(relation.getTarget() instanceof TableColumnRelationshipElement)) {
                                continue;
                        }
                        TableColumn column = ((TableColumnRelationshipElement) relation.getTarget()).getElement();
                        if (column != null && column.getTable() == table && !written.contains(column)) {
                                written.add(column);
                        }
                }
                return written;
        }

        /**
         * Row impact of the WHEN conditions of a conditional multi-table INSERT on the columns of one INTO clause: an
         * {@code fdr} from every subquery column a governing condition reads to every target column. A condition name
         * is bound like a VALUES name, to the select item the parser bound it to, so a qualified name
         * ({@code WHEN x.k > 0}), a name inside a function and a select-list alias all reach their column; they used to
         * be matched to the subquery's columns by spelling, and a qualified one never was. A name bound to a wildcard
         * reads the column the wildcard's expansion gives it, which exists when the columns behind the wildcard are known
         * (a declared table, a CTE). Over a table that is not declared the name may instead be a variable or parameter
         * of the enclosing block: the parser binds any name to a wildcard, while a column wins only when the table has
         * it. Such a name gets no edge rather than an invented column.
         */
        private void analyzeInsertWhenImpact(TSelectSqlStatement subquery, ResultSet subqueryRows, WhenScope scope,
                        Map<TExpression, List<Pair<ResultColumn, TObjectName>>> conditionReads, EffectType effectType) {
                List<Pair<ResultColumn, TObjectName>> sources = new ArrayList<Pair<ResultColumn, TObjectName>>();
                for (TExpression condition : scope.conditions) {
                        List<Pair<ResultColumn, TObjectName>> reads = conditionReads.get(condition);
                        if (reads == null) {
                                reads = new ArrayList<Pair<ResultColumn, TObjectName>>();
                                columnsInExpr visitor = new columnsInExpr();
                                visitor.setSkipFunction(true);
                                condition.inOrderTraverse(visitor);
                                // every name decides the routing, including those of a CASE's own conditions
                                List<TObjectName> names = new ArrayList<TObjectName>(visitor.getObjectNames());
                                names.addAll(caseConditionNames(condition));
                                for (TObjectName name : names) {
                                        ResultColumn source = insertAllSelectItem(subquery, subqueryRows, name, true);
                                        if (source != null) {
                                                reads.add(new Pair<ResultColumn, TObjectName>(source, name));
                                        }
                                }
                                conditionReads.put(condition, reads);
                        }
                        sources.addAll(reads);
                }
                if (sources.isEmpty()) {
                        return;
                }
                for (TableColumn target : scope.targets) {
                        ImpactRelationship relation = modelFactory.createImpactRelation();
                        relation.setEffectType(effectType);
                        relation.setTarget(new TableColumnRelationshipElement(target));
                        for (Pair<ResultColumn, TObjectName> source : sources) {
                                relation.addSource(new ResultColumnRelationshipElement(source.first, source.second.getLocation(),
                                                source.second));
                        }
                }
        }

        /**
         * The target column of each position of an INTO clause that names its own columns or values: the {@code i}-th
         * name of its column list, or without one the {@code i}-th column of a declared table, or, when neither names
         * it, a column named after its VALUES item when that item is a column, as {@code INSERT INTO t SELECT ...} names
         * a column after its select item. Null where none of these names it. Called while the INTO clauses are
         * collected, where {@link #bindInsertTableColumn} made the same columns, so their ids keep their order.
         */
        private List<TableColumn> insertIntoTargets(Table tableModel, TInsertIntoValue value) {
                TObjectNameList columnList = value.getColumnList() != null && value.getColumnList().size() > 0
                                ? value.getColumnList() : null;
                TResultColumnList values = insertIntoValues(value);
                boolean declared = tableModel.isCreateTable() && tableModel.getColumns() != null
                                && !containStarColumn(tableModel.getColumns());
                int width = columnList != null ? columnList.size() : (values != null ? values.size() : 0);
                List<TableColumn> targets = new ArrayList<TableColumn>(width);
                for (int i = 0; i < width; i++) {
                        TableColumn target = null;
                        if (columnList != null) {
                                target = modelFactory.createInsertTableColumn(tableModel, columnList.getObjectName(i));
                        } else if (declared) {
                                if (i < tableModel.getColumns().size()) {
                                        target = tableModel.getColumns().get(i);
                                }
                        } else {
                                TObjectName valueName = values.getResultColumn(i).getFieldAttr();
                                if (valueName != null) {
                                        target = modelFactory.createInsertTableColumn(tableModel, valueName);
                                }
                        }
                        targets.add(target);
                }
                return targets;
        }

        /**
         * Lineage of one INTO clause of a multi-table INSERT that names its own columns or values. The clause alone
         * decides where each value goes: target {@code i} ({@link #insertIntoTargets}) receives the {@code i}-th VALUES
         * item, or without VALUES the subquery's {@code i}-th column. The per-table mapping of an INSERT used to handle
         * these clauses by the subquery's column order, so {@code INSERT ALL INTO t (c2, c1) VALUES (v, w) SELECT v, w
         * FROM s} wrote {@code v} into {@code c1}, and without a declaration of {@code t} the clause had no lineage.
         *
         * @param firstOfTable whether this is the first such clause into its table, which carries the subquery's row
         *        filter to the table's rows once
         * @return the target columns, for the row impact of the WHEN conditions
         */
        private List<TableColumn> analyzeInsertIntoClause(TInsertSqlStatement stmt, SelfMappedInto into,
                        EffectType effectType, boolean firstOfTable) {
                List<TableColumn> targets = new ArrayList<TableColumn>();
                TSelectSqlStatement subquery = stmt.getSubQuery();
                ResultSet subqueryRows = null;
                if (subquery != null) {
                        Object model = modelManager.getModel(subquery);
                        if (!(model instanceof ResultSet) && subquery.getResultColumnList() != null) {
                                model = modelManager.getModel(subquery.getResultColumnList());
                        }
                        if (model instanceof ResultSet) {
                                subqueryRows = (ResultSet) model;
                        }
                }
                if (firstOfTable && subqueryRows != null && !subqueryRows.getRelationRows().getHoldRelations().isEmpty()) {
                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                        impactRelation.setEffectType(effectType);
                        impactRelation.addSource(
                                        new RelationRowsRelationshipElement<ResultSetRelationRows>(subqueryRows.getRelationRows()));
                        impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(into.table.getRelationRows()));
                }

                TResultColumnList values = insertIntoValues(into.value);
                int width = into.targets.size();
                // Without VALUES the subquery's columns fill the list in order; a wildcard of unknown width leaves each
                // position the set of items that could supply it.
                List<List<Integer>> candidates = values == null && subqueryRows != null
                                ? candidateSelectItems(subqueryRows.getColumns(), width) : null;
                // a set operation with a star of unknown width: the items of each of its selects (Mantis 4914)
                List<SelectPositions> setSelects = candidates != null && subquery.isCombinedQuery()
                                ? setOperationPositions(subquery, width) : null;
                Process process = modelFactory.createProcess(stmt);
                for (int i : insertIntoEmissionOrder(subquery, subqueryRows, values, width)) {
                        TableColumn target = into.targets.get(i);
                        if (target == null) {
                                continue;
                        }
                        if (values != null) {
                                if (i < values.size()) {
                                        analyzeInsertIntoValue(subquery, subqueryRows, target, values.getResultColumn(i).getExpr(),
                                                        effectType, process);
                                }
                        } else if (setSelects != null) {
                                if (hasCandidates(setSelects, i)) {
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(effectType);
                                        relation.setTarget(new TableColumnRelationshipElement(target));
                                        for (SelectPositions select : setSelects) {
                                                for (int k : select.candidates.get(i)) {
                                                        for (ResultColumn column : select.items.get(k)) {
                                                                relation.addSource(positionSource(column));
                                                        }
                                                }
                                        }
                                        relation.setProcess(process);
                                }
                        } else if (candidates != null && !candidates.get(i).isEmpty()) {
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(effectType);
                                relation.setTarget(new TableColumnRelationshipElement(target));
                                for (int k : candidates.get(i)) {
                                        relation.addSource(positionSource(subqueryRows.getColumns().get(k)));
                                }
                                relation.setProcess(process);
                        }
                }
                for (TableColumn target : into.targets) {
                        if (target != null) {
                                targets.add(target);
                        }
                }
                return targets;
        }

        /**
         * The order in which the positions of such an INTO clause emit their relations: by the subquery column their
         * value reads first, the order in which the per-table mapping emitted them, so a relation this mapping leaves
         * unchanged keeps its id in the output. A position whose value reads no subquery column comes last. Only the
         * order of emission depends on this, never which relations exist.
         */
        private List<Integer> insertIntoEmissionOrder(TSelectSqlStatement subquery, ResultSet subqueryRows,
                        TResultColumnList values, int width) {
                List<Integer> order = new ArrayList<Integer>(width);
                for (int i = 0; i < width; i++) {
                        order.add(i);
                }
                if (values == null || subqueryRows == null) {
                        return order;
                }
                final int[] firstRead = new int[width];
                for (int i = 0; i < width; i++) {
                        firstRead[i] = Integer.MAX_VALUE;
                        if (i >= values.size() || values.getResultColumn(i).getExpr() == null) {
                                continue;
                        }
                        columnsInExpr visitor = new columnsInExpr();
                        visitor.setSkipFunction(true);
                        values.getResultColumn(i).getExpr().inOrderTraverse(visitor);
                        for (TObjectName name : visitor.getObjectNames()) {
                                ResultColumn source = insertAllSelectItem(subquery, subqueryRows, name);
                                int position = source == null ? -1 : subqueryRows.getColumns().indexOf(source);
                                if (position >= 0 && position < firstRead[i]) {
                                        firstRead[i] = position;
                                }
                        }
                }
                Collections.sort(order, new Comparator<Integer>() {
                        @Override
                        public int compare(Integer a, Integer b) {
                                if (firstRead[a] != firstRead[b]) {
                                        return firstRead[a] < firstRead[b] ? -1 : 1;
                                }
                                return a.compareTo(b);
                        }
                });
                return order;
        }

        /**
         * Lineage of one VALUES item of an INTO clause of a multi-table INSERT into {@code target}. A VALUES item reads
         * the subquery's select list, and the parser binds each of its names to the select item it names
         * ({@code TObjectName.getSourceColumn()}), by alias or by column name. The item's value comes from those select
         * items, not from a column found by spelling: {@code VALUES (b)} over {@code SELECT x.w AS b} reads {@code x.w}.
         * For the same reason a function or CASE is not analyzed as a function node, which looks its arguments up by
         * spelling: the names inside its arguments and results are bound the same way and the function is recorded on
         * the relation, and the names in a CASE condition decide the row's value without being it, so they become an
         * {@code fdr}. A value that reads no select item keeps the general path, where a function is a node as in an
         * ordinary INSERT ... VALUES.
         */
        private void analyzeInsertIntoValue(TSelectSqlStatement subquery, ResultSet subqueryRows, TableColumn target,
                        TExpression valueExpr, EffectType effectType, Process process) {
                if (valueExpr == null) {
                        return;
                }
                columnsInExpr visitor = new columnsInExpr();
                visitor.setSkipFunction(true);
                valueExpr.inOrderTraverse(visitor);
                List<ResultColumn> sources = new ArrayList<ResultColumn>();
                List<TObjectName> unbound = new ArrayList<TObjectName>();
                for (TObjectName name : visitor.getObjectNames()) {
                        ResultColumn source = insertAllSelectItem(subquery, subqueryRows, name);
                        if (source != null) {
                                if (!sources.contains(source)) {
                                        sources.add(source);
                                }
                        } else if (!readsSubqueryTableDirectly(name)) {
                                unbound.add(name);
                        }
                }
                TParseTreeNode function = outermostFunction(valueExpr);
                List<TParseTreeNode> functions = function == null ? null : Collections.singletonList(function);
                if (sources.isEmpty() && unbound.isEmpty() && function != null) {
                        // a function of constants only: a node, as in an ordinary INSERT ... VALUES
                        analyzeFunctionDataFlowRelation(target, functions, effectType);
                        return;
                }
                if (!sources.isEmpty()) {
                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                        relation.setEffectType(effectType);
                        relation.setTarget(new TableColumnRelationshipElement(target));
                        relation.setProcess(process);
                        if (function != null) {
                                relation.setFunction(getFunctionName(function));
                        }
                        for (ResultColumn source : sources) {
                                relation.addSource(new ResultColumnRelationshipElement(source));
                        }
                }
                if (!unbound.isEmpty()) {
                        analyzeDataFlowRelation(target, unbound, effectType, functions, process);
                }
                List<ResultColumn> conditions = caseConditionSources(subquery, subqueryRows, valueExpr);
                if (!conditions.isEmpty()) {
                        ImpactRelationship impact = modelFactory.createImpactRelation();
                        impact.setEffectType(effectType);
                        impact.setTarget(new TableColumnRelationshipElement(target));
                        for (ResultColumn source : conditions) {
                                impact.addSource(new ResultColumnRelationshipElement(source));
                        }
                }
                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                if (subquerys != null && !subquerys.isEmpty()) {
                        analyzeSubqueryDataFlowRelation(target, subquerys, effectType);
                }
                List<TParseTreeNode> constants = visitor.getConstants();
                if (constants != null && !constants.isEmpty()) {
                        analyzeConstantDataFlowRelation(target, constants, effectType, functions);
                }
        }

        /**
         * Whether a VALUES name of a multi-table INSERT that is bound to no select item was credited by the resolver to a
         * table of the subquery. VALUES cannot read those tables directly, so such a column does not exist in the
         * lineage. A variable, a parameter, a bind variable, a sequence's NEXTVAL or CURRVAL and a pseudo-column carry
         * no such credit and keep the general path.
         */
        private static boolean readsSubqueryTableDirectly(TObjectName name) {
                return name.getSourceColumn() == null && name.getSourceTable() != null
                                && name.getDbObjectType() == EDbObjectType.column;
        }

        /** The function or CASE a VALUES item is, under any parentheses, or null. */
        private static TParseTreeNode outermostFunction(TExpression expr) {
                TExpression current = expr;
                while (current != null && current.getExpressionType() == EExpressionType.parenthesis_t) {
                        current = current.getLeftOperand();
                }
                if (current == null) {
                        return null;
                }
                if (current.getExpressionType() == EExpressionType.function_t && current.getFunctionCall() != null) {
                        return current.getFunctionCall();
                }
                if (current.getExpressionType() == EExpressionType.case_t && current.getCaseExpression() != null) {
                        return current.getCaseExpression();
                }
                return null;
        }

        /** The select items the conditions of the CASE expressions inside a VALUES item read. */
        private List<ResultColumn> caseConditionSources(TSelectSqlStatement subquery, ResultSet subqueryRows,
                        TExpression valueExpr) {
                List<ResultColumn> sources = new ArrayList<ResultColumn>();
                for (TObjectName name : caseConditionNames(valueExpr)) {
                        ResultColumn source = insertAllSelectItem(subquery, subqueryRows, name);
                        if (source != null && !sources.contains(source)) {
                                sources.add(source);
                        }
                }
                return sources;
        }

        /**
         * The names in the conditions of the CASE expressions inside {@code expr}: each CASE's input and the comparison of
         * each WHEN, names inside functions included. {@code columnsInExpr} in its flattening mode reads only a CASE's
         * results.
         */
        private List<TObjectName> caseConditionNames(TExpression expr) {
                final List<TCaseExpression> cases = new ArrayList<TCaseExpression>();
                expr.acceptChildren(new TParseTreeVisitor() {
                        @Override
                        public void preVisit(TCaseExpression node) {
                                cases.add(node);
                        }
                });
                List<TObjectName> names = new ArrayList<TObjectName>();
                for (TCaseExpression caseExpr : cases) {
                        List<TExpression> conditions = new ArrayList<TExpression>();
                        if (caseExpr.getInput_expr() != null) {
                                conditions.add(caseExpr.getInput_expr());
                        }
                        TWhenClauseItemList items = caseExpr.getWhenClauseItemList();
                        for (int i = 0; items != null && i < items.size(); i++) {
                                if (items.getWhenClauseItem(i).getComparison_expr() != null) {
                                        conditions.add(items.getWhenClauseItem(i).getComparison_expr());
                                }
                        }
                        for (TExpression condition : conditions) {
                                columnsInExpr visitor = new columnsInExpr();
                                visitor.setSkipFunction(true);
                                condition.inOrderTraverse(visitor);
                                names.addAll(visitor.getObjectNames());
                        }
                }
                return names;
        }

        private ResultColumn insertAllSelectItem(TSelectSqlStatement subquery, ResultSet subqueryRows, TObjectName name) {
                return insertAllSelectItem(subquery, subqueryRows, name, false);
        }

        /**
         * The subquery column a VALUES name of a multi-table INSERT reads, given the select item the parser bound it
         * to; for a wildcard item null, or with {@code throughWildcard} the column the wildcard's expansion gives the
         * name (a WHEN condition name). Of a set operation ({@code UNION ALL} ...) that item belongs to one branch, whose
         * rows are only part of the subquery's, so the name reads the set's column at the item's position in its
         * branch's result, counted after any wildcard before it is expanded. When a wildcard of unknown width stands
         * before it, that position is unknown and the item's own branch column is what can be proven.
         */
        private ResultColumn insertAllSelectItem(TSelectSqlStatement subquery, ResultSet subqueryRows, TObjectName name,
                        boolean throughWildcard) {
                TResultColumn item = name == null ? null : name.getSourceColumn();
                if (item == null || subquery == null) {
                        return null;
                }
                ResultColumn own = selectItemColumn(item, throughWildcard ? name : null);
                if (own == null) {
                        return null;
                }
                if (!subquery.isCombinedQuery() || subqueryRows == null) {
                        return own;
                }
                TSelectSqlStatement branch = branchHoldingSelectItem(subquery, item);
                Object branchModel = branch == null ? null
                                : modelManager.getModel(branch.getResultColumnList() != null ? branch.getResultColumnList() : branch);
                if (!(branchModel instanceof ResultSet)) {
                        return own;
                }
                List<ResultColumn> branchColumns = ((ResultSet) branchModel).getColumns();
                int index = branchColumns.indexOf(own);
                if (index < 0 || index >= subqueryRows.getColumns().size()) {
                        return own;
                }
                for (int k = 0; k < index; k++) {
                        if (branchColumns.get(k).isStarColumn()) {
                                return own;
                        }
                }
                ResultColumn column = subqueryRows.getColumns().get(index);
                return column.isStarColumn() ? own : column;
        }

        /**
         * The result column a name bound to select item {@code item} reads: the item's own column, or, given the
         * {@code name}, for a wildcard item the column its expansion gives that name (the expansion is keyed by column
         * name and holds the columns of a declared table or of a CTE). Null for a wildcard item without a name or whose
         * expansion does not name it.
         */
        private ResultColumn selectItemColumn(TResultColumn item, TObjectName name) {
                Object model = modelManager.getModel(item);
                if (model instanceof ResultColumn) {
                        return ((ResultColumn) model).isStarColumn() ? null : (ResultColumn) model;
                }
                if (name != null && model instanceof LinkedHashMap) {
                        for (Object value : ((LinkedHashMap<?, ?>) model).values()) {
                                if (value instanceof ResultColumn && !((ResultColumn) value).isStarColumn()
                                                && DlineageUtil.sameColumnName(((ResultColumn) value).getName(), name)) {
                                        return (ResultColumn) value;
                                }
                        }
                }
                return null;
        }

        /** The branch of a set operation whose select list holds {@code item}, or null. */
        private static TSelectSqlStatement branchHoldingSelectItem(TSelectSqlStatement setOperation, TResultColumn item) {
                Deque<TSelectSqlStatement> stack = new ArrayDeque<TSelectSqlStatement>();
                stack.push(setOperation);
                while (!stack.isEmpty()) {
                        TSelectSqlStatement current = stack.pop();
                        if (current.isCombinedQuery()) {
                                if (current.getRightStmt() != null) {
                                        stack.push(current.getRightStmt());
                                }
                                if (current.getLeftStmt() != null) {
                                        stack.push(current.getLeftStmt());
                                }
                        } else if (current.getResultColumnList() != null) {
                                for (int i = 0; i < current.getResultColumnList().size(); i++) {
                                        if (current.getResultColumnList().getResultColumn(i) == item) {
                                                return current;
                                        }
                                }
                        }
                }
                return null;
        }

        private TableColumn matchColumn(List<TableColumn> tableColumns, TableColumn targetColumn) {
                String columnName = targetColumn.getName();
                if (tableColumns == null) {
                        return null;
                }
                for (int i = 0; i < tableColumns.size(); i++) {
                        TableColumn column = tableColumns.get(i);
                        if (column.getColumnObject() == null) {
                                continue;
                        }
                        if(column.isStruct() && targetColumn.isStruct()) {
                                List<String> names = SQLUtil.parseNames(column.getName());
                                List<String> targetNames = SQLUtil
                                                .parseNames(targetColumn.getName());
                                if (!DlineageUtil.sameColumnName(targetNames.get(0), names.get(0))) {
                                        continue;
                                }
                        }
                        if (DlineageUtil.sameColumnName(column.getColumnObject().toString(), columnName)) {
                                return column;
                        }
                }
                return null;
        }
        
        private TableColumn matchColumn(List<TableColumn> tableColumns, TObjectName columnName) {
                if (tableColumns == null) {
                        return null;
                }
                TableColumn declaredColumn = null;
                for (int i = 0; i < tableColumns.size(); i++) {
                        TableColumn column = tableColumns.get(i);
                        if (column.getColumnObject() == null) {
                                continue;
                        }
                        if (!DlineageUtil.sameColumnName(column.getColumnObject(), columnName)) {
                                continue;
                        }
                        // objcol.a2 is not the column objcol.a1 was written into (Mantis #4747)
                        if (DlineageUtil.sameFieldLeaf(column.getColumnObject(), columnName)) {
                                return column;
                        }
                        // A declared table has no column for an attribute: objcol.a1 lands in the declared objcol, where
                        // ModelFactory.createTableColumn puts an UPDATE or MERGE target and a read of it. Missing it here sent
                        // the write to the declared column at its list position instead, or dropped it (Mantis #4747).
                        if (declaredColumn == null && column.getTable() != null && column.getTable().isCreateTable()
                                        && DlineageUtil.isFieldPath(columnName) && !DlineageUtil.isFieldPath(column.getColumnObject())) {
                                declaredColumn = column;
                        }
                }
                return declaredColumn;
        }

        private ResultColumn matchResultColumn(List<ResultColumn> resultColumns, ResultColumn resultColumn) {
                if (resultColumns == null) {
                        return null;
                }

                TObjectName columnName = getObjectName(resultColumn);
                if (columnName == null) {
                        return null;
                }

                for (int i = 0; i < resultColumns.size(); i++) {
                        ResultColumn column = resultColumns.get(i);
                        if (column.getAlias() != null
                                        && DlineageUtil.sameColumnName(column.getAlias(), columnName))
                                return column;
                        if (column.getName() != null && DlineageUtil.sameColumnName(column.getName(), columnName))
                                return column;
                        if (column.getName() != null && column.isStarColumn()) {
                                if (isBareStarNode(column.getColumnObject())) {
                                        return column;
                                } else {
                                        TObjectName columnObjectName = getObjectName(column);
                                        if (columnObjectName.getTableString() != null
                                                        && columnObjectName.getTableString().equals(getResultSetAlias(resultColumn))) {
                                                return column;
                                        }
                                }
                        }
                }
                return null;
        }

        private String getResultSetAlias(ResultColumn resultColumn) {
                ResultSet resultSet = resultColumn.getResultSet();
                if (resultSet instanceof QueryTable) {
                        return ((QueryTable) resultSet).getAlias();
                }
                return null;
        }

        private ResultColumn matchResultColumn(List<ResultColumn> resultColumns, TObjectName columnName) {
                if (resultColumns == null) {
                        return null;
                }
                for (int i = 0; i < resultColumns.size(); i++) {
                        ResultColumn column = resultColumns.get(i);
                        if (column.getAlias() != null
                                        && DlineageUtil.sameColumnName(column.getAlias(), columnName))
                                return column;
                        if (column.getName() != null && DlineageUtil.sameColumnName(column.getName(), columnName))
                                return column;
                        if (column.getName() != null && column.isStarColumn()) {
                                if (isBareStarNode(column.getColumnObject())) {
                                        return column;
                                } else {
                                        TObjectName columnObjectName = getObjectName(column);
                                        if (columnObjectName.getTableString() != null
                                                        && columnObjectName.getTableString().equals(columnName.getTableString())) {
                                                return column;
                                        }
                                }
                        }
                }
                return null;
        }

        /** Rule R8: the select items of {@code columns}, each as its result columns; a STRUCT item's fields are one item. */
        private List<List<ResultColumn>> selectItemGroups(List<ResultColumn> columns) {
                List<List<ResultColumn>> groups = new ArrayList<List<ResultColumn>>();
                for (int j = 0; j < columns.size();) {
                        int width = columns.get(j).isStarColumn() ? 1 : selectItemWidth(columns, j);
                        groups.add(new ArrayList<ResultColumn>(columns.subList(j, j + width)));
                        j += width;
                }
                return groups;
        }

        /**
         * Rule R8: how many select items {@code columns} holds from {@code j} on, the fields of a STRUCT item one item. A
         * column-list mapper pairs a star of unknown width with one more target column while more target columns remain
         * than these items: the select list is as wide as the column list, so the items after the star fill the last
         * columns (owner ruling 2026-10-07). Counting result columns instead let a STRUCT of two fields after the star
         * take the column right after it. Only the first {@code end} columns are the select list's: a mapper appends the
         * columns it expands a star into while it pairs.
         */
        private int selectItemsFrom(List<ResultColumn> columns, int j, int end) {
                List<ResultColumn> selectList = columns.subList(0, Math.min(end, columns.size()));
                int items = 0;
                for (int k = j; k < selectList.size(); items++) {
                        k += selectList.get(k).isStarColumn() ? 1 : selectItemWidth(selectList, k);
                }
                return items;
        }

        /** How many of {@code columns} are stars. */
        private static int starColumnCount(List<ResultColumn> columns) {
                int stars = 0;
                for (ResultColumn column : columns) {
                        if (column.isStarColumn()) {
                                stars++;
                        }
                }
                return stars;
        }

        /**
         * Pairs the column list of a view with a select list that has two or more stars of unknown width (Mantis 4915):
         * each view column reads every select item that can stand at its position ({@link #candidateSelectItems}), as an
         * INSERT column list does; a STRUCT item proven at the position feeds its fields. Pairing them one by one split the
         * list between the stars at a boundary nothing in the SQL proves. A set operation with a star of unknown width
         * gives the items of each of its selects (Mantis 4914), for a view or, {@code effectType} create_table, the column
         * list of CREATE TABLE ... AS.
         */
        private void mapViewColumnsByCandidates(Table viewModel, List<TObjectName> aliases, List<SelectPositions> selects,
                        EffectType effectType, Process process) {
                for (int i = 0; i < aliases.size(); i++) {
                        TObjectName alias = aliases.get(i);
                        if (!hasCandidates(selects, i)) {
                                continue;
                        }
                        TableColumn viewColumn;
                        if (effectType == EffectType.create_view) {
                                viewColumn = modelFactory.createViewColumn(viewModel, alias, i, true);
                                appendTableColumnToSQLEnv(viewModel, viewColumn);
                        } else {
                                // the column list of CREATE TABLE ... AS
                                viewColumn = modelFactory.createTableColumn(viewModel, alias, true);
                                if (viewColumn == null) {
                                        continue;
                                }
                        }
                        for (SelectPositions select : selects) {
                                List<Integer> candidates = select.candidates.get(i);
                                if (candidates.isEmpty()) {
                                        continue;
                                }
                                List<ResultColumn> single = candidates.size() == 1 ? select.items.get(candidates.get(0)) : null;
                                if (single != null && (single.size() > 1 || structFieldPaths.containsKey(single.get(0)))) {
                                        feedFromStructItem(viewColumn, single, alias, effectType, process, true);
                                        continue;
                                }
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(effectType);
                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                for (int k : candidates) {
                                        for (ResultColumn column : select.items.get(k)) {
                                                relation.addSource(positionSource(column));
                                        }
                                }
                                relation.setProcess(process);
                        }
                }
        }

        /** The columns a view's column list names; a constraint of it (Oracle CONSTRAINT pk PRIMARY KEY (a)) has no alias and takes no position. */
        private static List<TObjectName> viewColumnAliases(TViewAliasItemList viewItems) {
                List<TObjectName> aliases = new ArrayList<TObjectName>();
                for (int i = 0; i < viewItems.size(); i++) {
                        if (viewItems.getViewAliasItem(i).getAlias() != null) {
                                aliases.add(viewItems.getViewAliasItem(i).getAlias());
                        }
                }
                return aliases;
        }

        /**
         * Pairs the column list of a CTE with a select list that has two or more stars of unknown width (Mantis 4916): each
         * CTE column reads every select item that can stand at its position ({@link #candidateSelectItems}), as an INSERT
         * column list does. Pairing them one by one gave every column to the first star and ran past the end. A STRUCT
         * item proven at its position is one CTE column with a field node per field, as the one-by-one pairing builds it.
         * A set operation with a star of unknown width gives the items of each of its selects (Mantis 4914), for a CTE or
         * the alias list of a derived table.
         */
        private void mapCteColumnsByCandidates(QueryTable queryTable, List<SelectPositions> selects, TObjectNameList cteColumns) {
                mapCteColumnsByCandidates(queryTable, selects, cteColumns, null);
        }

        /**
         * {@link #mapCteColumnsByCandidates(QueryTable, List, TObjectNameList)} with relations of {@code process}: the UPDATE
         * that reads the CTE (Mantis 5003) keeps its process on them; a query passes null.
         */
        private void mapCteColumnsByCandidates(QueryTable queryTable, List<SelectPositions> selects, TObjectNameList cteColumns,
                        Process process) {
                for (int i = 0; i < queryTable.getColumns().size(); i++) {
                        ResultColumn targetColumn = queryTable.getColumns().get(i);
                        for (SelectPositions select : selects) {
                                List<Integer> candidates = select.candidates.get(i);
                                List<ResultColumn> single = candidates.size() == 1 ? select.items.get(candidates.get(0)) : null;
                                if (single != null && structFieldPaths.containsKey(single.get(0))) {
                                        for (ResultColumn field : single) {
                                                createCteSelectRelation(process, targetColumn, field);
                                                StructFieldPath path = structFieldPaths.get(field);
                                                ResultColumn node = builtFieldNodeAt(targetColumn, path.path);
                                                if (node == null) {
                                                        node = structFieldNode(targetColumn, path.path, cteColumns.getObjectName(i), path.item);
                                                }
                                                DataFlowRelationship nodeRelation = modelFactory.createDataFlowRelation();
                                                nodeRelation.setEffectType(EffectType.select);
                                                nodeRelation.setTarget(new ResultColumnRelationshipElement(node));
                                                nodeRelation.addSource(new ResultColumnRelationshipElement(field));
                                                nodeRelation.setProcess(process);
                                        }
                                        continue;
                                }
                                for (int k : candidates) {
                                        for (ResultColumn sourceColumn : select.items.get(k)) {
                                                // a CTE column renames a position: the names a star links stay the star's, never the column's
                                                createCteSelectRelation(process, targetColumn, sourceColumn, true);
                                                setOperationFieldNodes(targetColumn, sourceColumn);
                                        }
                                }
                        }
                }
        }

        /** The first result column of each item, which says whether the item is a star. */
        private static List<ResultColumn> groupHeads(List<List<ResultColumn>> groups) {
                List<ResultColumn> heads = new ArrayList<ResultColumn>(groups.size());
                for (List<ResultColumn> group : groups) {
                        heads.add(group.get(0));
                }
                return heads;
        }

        /**
         * Feeds {@code tableColumn}, the target at {@code position} of a list, from each select of {@code selects}
         * ({@link #feedCandidateItems}).
         */
        private void feedSelectPositions(TableColumn tableColumn, List<SelectPositions> selects, int position,
                        EffectType effectType, Process process) {
                for (SelectPositions select : selects) {
                        if (!select.candidates.get(position).isEmpty()) {
                                feedCandidateItems(tableColumn, tableColumn.getColumnObject(), select.items,
                                                select.candidates.get(position), effectType, process);
                        }
                }
        }

        /**
         * Feeds {@code tableColumn} from the select items {@link #candidateSelectItems} names for it: the one item at its
         * position when the position is proven, a STRUCT item by its fields (rule R8); every candidate item, whole, when
         * it is not.
         */
        private void feedCandidateItems(TableColumn tableColumn, TObjectName position, List<List<ResultColumn>> groups,
                        List<Integer> candidates, EffectType effectType, Process process) {
                if (candidates.size() == 1) {
                        List<ResultColumn> group = groups.get(candidates.get(0));
                        if (group.size() > 1 || structFieldPaths.containsKey(group.get(0))) {
                                // one candidate: the sum rule proves the position, behind stars of unknown width too (owner ruling
                                // 2026-10-07)
                                feedFromStructItem(tableColumn, group, position, effectType, process, false);
                                return;
                        }
                }
                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(effectType);
                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                for (int k : candidates) {
                        for (ResultColumn column : groups.get(k)) {
                                relation.addSource(positionSource(column));
                        }
                }
                relation.setProcess(process);
                if (candidates.size() == 1) {
                        feedBuiltFieldNodes(tableColumn, groups.get(candidates.get(0)).get(0), effectType, process, false);
                }
        }

        /** The select items of one select and, for each target position of a list, the indexes of those that can stand at it. */
        private static final class SelectPositions {
                final List<List<ResultColumn>> items;
                final List<List<Integer>> candidates;

                SelectPositions(List<List<ResultColumn>> items, List<List<Integer>> candidates) {
                        this.items = items;
                        this.candidates = candidates;
                }
        }

        /** {@link SelectPositions} of the select whose result columns are {@code columns}, for a list of {@code width} targets. */
        private SelectPositions selectPositions(List<ResultColumn> columns, int width) {
                return selectPositions(columns, width, null);
        }

        /**
         * {@link SelectPositions} of the select whose result columns are {@code columns}, for a list of {@code width} targets
         * that, when {@code unique} is not null, may name only the first columns of the select; a column of the select named
         * like one of {@code unique} stands within the list ({@link #candidateSelectItems(List, int, boolean[])}).
         */
        private SelectPositions selectPositions(List<ResultColumn> columns, int width, List<TObjectName> unique) {
                List<List<ResultColumn>> items = selectItemGroups(columns);
                return new SelectPositions(items, candidateSelectItems(groupHeads(items), width, namedInList(items, unique)));
        }

        /** For each item, whether it is a column named like one of {@code unique}; null when {@code unique} is. */
        private boolean[] namedInList(List<List<ResultColumn>> items, List<TObjectName> unique) {
                if (unique == null) {
                        return null;
                }
                boolean[] named = new boolean[items.size()];
                for (int k = 0; k < items.size(); k++) {
                        ResultColumn head = items.get(k).get(0);
                        for (TObjectName name : unique) {
                                named[k] |= !head.isStarColumn() && referencesColumn(name, head);
                        }
                }
                return named;
        }

        /**
         * For a column list of a view or CREATE TABLE AS that may name fewer columns than its query has
         * ({@link #columnListMayBeShorter}): its names, which no other column of the query can have, as PostgreSQL rejects a
         * column name twice; none where a second column of a name is renamed (DuckDB). Null where the list names every
         * column, so that its length is the width of the query.
         */
        private List<TObjectName> shorterList(List<TObjectName> names) {
                if (!columnListMayBeShorter(option.getVendor())) {
                        return null;
                }
                return option.getVendor() == EDbVendor.dbvduckdb ? Collections.<TObjectName>emptyList() : names;
        }

        /**
         * For the column list {@code names} of a derived table or a CTE that may name fewer columns than its query has
         * ({@link #columnListMayBeShorter}): its names the query reads through {@code table}, which no other column of the
         * query can have, as PostgreSQL rejects such a read as ambiguous; none where a second column of a name is renamed
         * (DuckDB). Null where the list names every column.
         */
        private List<TObjectName> shorterList(TObjectNameList names, TTable table) {
                if (names == null || !columnListMayBeShorter(option.getVendor())) {
                        return null;
                }
                List<TObjectName> read = new ArrayList<TObjectName>();
                TObjectNameList references = table == null ? null : table.getLinkedColumns();
                for (int i = 0; option.getVendor() != EDbVendor.dbvduckdb && i < names.size(); i++) {
                        for (int j = 0; references != null && j < references.size(); j++) {
                                if (DlineageUtil.sameColumnName(names.getObjectName(i), references.getObjectName(j))) {
                                        read.add(names.getObjectName(i));
                                        break;
                                }
                        }
                }
                return read;
        }

        /**
         * Whether a column list of {@code vendor} may name fewer columns than its query has, the others keeping their names:
         * PostgreSQL (parse_cte.c, "we allow it to be shorter for consistency with Alias handling"; CREATE TABLE AS, "too
         * few column names are OK"), the databases built on it, and DuckDB (1.4.4).
         */
        private static boolean columnListMayBeShorter(EDbVendor vendor) {
                return vendor == EDbVendor.dbvpostgresql || vendor == EDbVendor.dbvgreenplum || vendor == EDbVendor.dbvedb
                                || vendor == EDbVendor.dbvgaussdb || vendor == EDbVendor.dbvduckdb;
        }

        /** Whether a select of {@code selects} has an item that can stand at {@code position}. */
        private static boolean hasCandidates(List<SelectPositions> selects, int position) {
                for (SelectPositions select : selects) {
                        if (!select.candidates.get(position).isEmpty()) {
                                return true;
                        }
                }
                return false;
        }

        /**
         * Mantis 4914: the {@link SelectPositions} of each select of the set operation {@code stmt}, for a list of
         * {@code width} targets; null when no select has a star of unknown width, or a select has no result set. The
         * columns of a set operation are named after one select, so one star there can stand for positions the other
         * selects fill with different columns: only the selects tell them apart, each against the width of the list.
         */
        private List<SelectPositions> setOperationPositions(TSelectSqlStatement stmt, int width) {
                return setOperationPositions(stmt, width, null);
        }

        /**
         * {@link #setOperationPositions(TSelectSqlStatement, int)} for a list that, when {@code unique} is not null, may name
         * only the first columns ({@link #shorterList(List)}). Every select has the width of the set operation: a select
         * without a star states it, and the first select, which names the columns, bounds it where a column of it named
         * like one of {@code unique} stands within the list with no star after it. Without a bound the selects can run
         * past the list.
         */
        private List<SelectPositions> setOperationPositions(TSelectSqlStatement stmt, int width, List<TObjectName> unique) {
                List<ResultSet> selects = new ArrayList<ResultSet>();
                boolean star = false;
                Deque<TSelectSqlStatement> stack = new ArrayDeque<TSelectSqlStatement>();
                stack.push(stmt);
                while (!stack.isEmpty()) {
                        TSelectSqlStatement current = stack.pop();
                        if (current.isCombinedQuery()) {
                                // the right branch first, so that the left one comes first
                                if (current.getRightStmt() != null) {
                                        stack.push(current.getRightStmt());
                                }
                                if (current.getLeftStmt() != null) {
                                        stack.push(current.getLeftStmt());
                                }
                                continue;
                        }
                        ResultSet select = current.getResultColumnList() == null ? null : setOperationBranch(current);
                        if (select == null) {
                                return null;
                        }
                        selects.add(select);
                        star |= starColumnCount(select.getColumns()) > 0;
                }
                if (!star || selects.size() < 2) {
                        return null;
                }
                if (unique != null) {
                        for (ResultSet select : selects) {
                                if (starColumnCount(select.getColumns()) == 0) {
                                        width = Math.max(width, selectItemGroups(select.getColumns()).size());
                                        unique = null;
                                        break;
                                }
                        }
                }
                int widest = Integer.MAX_VALUE;
                if (unique != null) {
                        List<List<ResultColumn>> first = selectItemGroups(selects.get(0).getColumns());
                        widest = widest(groupHeads(first), width, namedInList(first, unique));
                }
                List<SelectPositions> positions = new ArrayList<SelectPositions>(selects.size());
                for (int s = 0; s < selects.size(); s++) {
                        positions.add(setOperationSelect(selects.get(s).getColumns(), width, widest,
                                        s == 0 ? unique : Collections.<TObjectName>emptyList(), unique != null));
                }
                // a column of the set operation whose sources are exactly the selects' items at a position feeds that position
                // itself, as before: only where a star stands for several positions do the selects tell them apart
                Object model = modelManager.getModel(stmt);
                if (model instanceof ResultSet) {
                        SelectPositions own = setOperationSelect(((ResultSet) model).getColumns(), width, widest, unique,
                                        unique != null);
                        boolean through = false;
                        for (int i = 0; i < width; i++) {
                                List<Integer> column = own.candidates.get(i);
                                if (column.size() == 1 && carriesExactly(own.items.get(column.get(0)), positions, i)) {
                                        for (SelectPositions select : positions) {
                                                select.candidates.get(i).clear();
                                        }
                                        through = true;
                                } else {
                                        column.clear();
                                }
                        }
                        if (through) {
                                positions.add(0, own);
                        }
                }
                return positions;
        }

        /**
         * {@link SelectPositions} of a select of a set operation: for a list of {@code width} targets, when not
         * {@code open}; for one that may name only the first of at most {@code widest} columns, when {@code open}.
         */
        private SelectPositions setOperationSelect(List<ResultColumn> columns, int width, int widest,
                        List<TObjectName> unique, boolean open) {
                if (!open || widest == Integer.MAX_VALUE) {
                        return selectPositions(columns, width, open ? unique : null);
                }
                List<List<ResultColumn>> items = selectItemGroups(columns);
                List<ResultColumn> heads = groupHeads(items);
                List<List<Integer>> candidates = new ArrayList<List<Integer>>(width);
                for (int i = 0; i < width; i++) {
                        candidates.add(new ArrayList<Integer>());
                }
                // the set operation is from width to widest columns wide: the items that can stand at a position at any of them
                for (int total = width; total <= widest; total++) {
                        List<List<Integer>> at = candidateSelectItems(heads, total);
                        for (int i = 0; i < width; i++) {
                                for (int k : at.get(i)) {
                                        if (!candidates.get(i).contains(k)) {
                                                candidates.get(i).add(k);
                                        }
                                }
                        }
                }
                for (List<Integer> position : candidates) {
                        Collections.sort(position);
                }
                return new SelectPositions(items, candidates);
        }

        /**
         * The widest a select with the items {@code items} can be under a list of {@code width} names that may name only
         * its first columns, where an item that is {@code named} stands within the list: past the last such item only the
         * items after it, unless one of them is a star. MAX_VALUE without such a bound.
         */
        private static int widest(List<ResultColumn> items, int width, boolean[] named) {
                int last = -1;
                for (int k = 0; k < items.size(); k++) {
                        if (named[k]) {
                                last = k;
                        }
                }
                if (last < 0) {
                        return Integer.MAX_VALUE;
                }
                for (int k = last + 1; k < items.size(); k++) {
                        if (items.get(k).getName() != null && items.get(k).isStarColumn()) {
                                return Integer.MAX_VALUE;
                        }
                }
                return Math.max(width, width - 1 + items.size() - last);
        }

        /**
         * Whether the columns {@code item} of a set operation read exactly the items the selects {@code positions} have at
         * {@code position}, as the set operation's mapping recorded them ({@link #setColumnSources}).
         */
        private boolean carriesExactly(List<ResultColumn> item, List<SelectPositions> positions, int position) {
                Set<ResultColumn> sources = Collections.newSetFromMap(new IdentityHashMap<ResultColumn, Boolean>());
                for (ResultColumn column : item) {
                        List<ResultColumn> recorded = setColumnSources.get(column);
                        if (recorded == null) {
                                return false;
                        }
                        sources.addAll(recorded);
                }
                Set<ResultColumn> items = Collections.newSetFromMap(new IdentityHashMap<ResultColumn, Boolean>());
                for (SelectPositions select : positions) {
                        for (int k : select.candidates.get(position)) {
                                items.addAll(select.items.get(k));
                        }
                }
                return sources.equals(items);
        }

        /**
         * For each declared target column of an INSERT, the select-list items that could supply it when
         * the select list contains a wildcard whose width is unknown.
         *
         * <p>{@code INSERT INTO t SELECT c.*, o.*} projects {@code |c| + |o|} columns onto t's declared
         * columns, but with neither width known the boundary between the two wildcards is unknown as
         * well, so NO target column can be attributed to one of them. Binding by ordinal — which is
         * what this method replaces — produced a confident and arbitrary split
         * ({@code CUSTOMERS.* -> ORDERNAME}, {@code ORDERS.* -> ORDERALTNUM}) that no fact in the
         * script supports, and it also let a partial wildcard expansion name a specific column as the
         * first one behind the star.
         *
         * <p>The interval each item can occupy follows from the widths that ARE known, plus the fact
         * that the widths must SUM to the number of target columns. An item starts after everything
         * before it, so its earliest position is bounded below both by the definitely-one-column items
         * before it and by how little the items from it onward can cover; its latest position is
         * bounded above both by the definitely-one-column items after it and by how far the items
         * before it can push it. A select list with no unknown widths therefore yields exactly one
         * position per item — the ordinal mapping — which is why this is a generalization of the
         * positional rule and not a different rule. So does a trailing concrete item after any number
         * of wildcards, which the sum constraint pins to the last position.
         *
         * <p>The result is a candidate SET, deliberately over-approximate where the mapping is
         * undetermined: every candidate carries the {@code *} marker that says the column behind it is
         * unknown. A narrower answer would have to invent the boundary, and an empty answer would hide
         * the dependency altogether, which is the failure mode nobody can see in the output.
         *
         * @param items select-list result columns, in projection order
         * @param targetWidth number of declared target columns
         * @return for each target position, the indexes into {@code items} that could supply it
         */
        private static List<List<Integer>> candidateSelectItems(List<ResultColumn> items, int targetWidth) {
                return candidateSelectItems(items, targetWidth, null);
        }

        /**
         * {@link #candidateSelectItems(List, int)} for a list that may name only the first columns of the select when
         * {@code listed} is not null ({@link #shorterList(List)}): the select can run past the list, so the widths reach it
         * but need not sum to it. A column past the list keeps its name, so an item named like a name of the list that no
         * other column can have ({@code listed[k]}) stands within it, and so does every item before it.
         */
        private static List<List<Integer>> candidateSelectItems(List<ResultColumn> items, int targetWidth, boolean[] listed) {
                int size = items.size();
                int[] minWidth = new int[size];
                int[] maxWidth = new int[size];
                for (int k = 0; k < size; k++) {
                        boolean star = items.get(k).getName() != null && items.get(k).isStarColumn();
                        // A wildcard of unknown width may contribute nothing at all (SELECT c.* EXCEPT(...) over
                        // a two-column table) or the whole target, so it constrains neither end.
                        minWidth[k] = star ? 0 : 1;
                        maxWidth[k] = star ? targetWidth : 1;
                }
                // the latest position each item can start at, and the first item past the last one
                long[] latestStart = new long[size + 1];
                latestStart[size] = Long.MAX_VALUE;
                for (int k = size - 1; listed != null && k >= 0; k--) {
                        latestStart[k] = latestStart[k + 1] == Long.MAX_VALUE ? Long.MAX_VALUE : latestStart[k + 1] - minWidth[k];
                        if (listed[k]) {
                                latestStart[k] = Math.min(latestStart[k], targetWidth - 1);
                        }
                }
                List<List<Integer>> candidates = new ArrayList<List<Integer>>(targetWidth);
                for (int i = 0; i < targetWidth; i++) {
                        candidates.add(new ArrayList<Integer>());
                }
                for (int k = 0; k < size; k++) {
                        int minStart = 0;
                        int maxStart = 0;
                        for (int l = 0; l < k; l++) {
                                minStart += minWidth[l];
                                maxStart += maxWidth[l];
                        }
                        int minAfter = 0;
                        for (int l = k + 1; l < size; l++) {
                                minAfter += minWidth[l];
                        }
                        // Widths sum to targetWidth, so item k cannot start earlier than the point from which
                        // everything from k onward could still fill the rest. That is what pins a trailing
                        // concrete item to the last position instead of leaving it a candidate for every one.
                        long maxFromHere = 0;
                        for (int l = k; l < size; l++) {
                                maxFromHere += maxWidth[l];
                        }
                        int lowest = Math.max(minStart, (int) Math.max(0, targetWidth - maxFromHere));
                        // a list that may be shorter: the items after this one need not fit into the list, but a star ends before
                        // the latest start of the item after it
                        long highest = listed == null ? Math.min(targetWidth - 1 - minAfter, maxStart + maxWidth[k] - 1)
                                        : Math.min(maxStart + maxWidth[k] - 1, minWidth[k] == 0 ? latestStart[k] - 1 : latestStart[k]);
                        for (int i = Math.max(0, lowest); i <= highest && i < targetWidth; i++) {
                                candidates.get(i).add(k);
                        }
                }
                return candidates;
        }

        private void analyzeInsertStmt(TInsertSqlStatement stmt) {
                Map<Table, List<TObjectName>> insertTableKeyMap = new LinkedHashMap<Table, List<TObjectName>>();
                Map<Table, List<TResultColumn>> insertTableValueMap = new LinkedHashMap<Table, List<TResultColumn>>();
                // The insert target's columns, per target table model (a table model is the table's identity).
                Map<Table, List<TableColumn>> tableColumnMap = new LinkedHashMap<Table, List<TableColumn>>();
                List<Table> inserTables = new ArrayList<Table>();
                // INTO clauses of a multi-table INSERT that name their own columns or values, mapped by
                // analyzeInsertIntoClause instead of the per-table mapping below
                List<SelfMappedInto> selfMappedIntoClauses = new ArrayList<SelfMappedInto>();
                // for an entry of inserTables that is an INTO clause of a conditional multi-table INSERT: its position and
                // the WHEN conditions routing rows to it
                Map<Integer, Pair<Integer, List<TExpression>>> plainIntoConditions = new HashMap<Integer, Pair<Integer, List<TExpression>>>();
                // the columns each INTO clause of a conditional multi-table INSERT writes, with its WHEN conditions
                List<WhenScope> whenScopes = new ArrayList<WhenScope>();
                boolean hasInsertColumns = false;
                
                EffectType effectType = EffectType.insert;
                if(stmt.getInsertToken()!=null && stmt.getInsertToken().toString().toLowerCase(Locale.ROOT).startsWith("replace")) {
                        effectType = EffectType.replace;
                }
                
                if (stmt.getInsertConditions() != null && stmt.getInsertConditions().size() > 0) {
                        // the INTO clauses of every WHEN branch, then those of the ELSE branch, which had no lineage before,
                        // each with the WHEN conditions that route rows to it
                        List<TInsertIntoValue> intoClauses = new ArrayList<TInsertIntoValue>();
                        List<List<TExpression>> intoConditions = new ArrayList<List<TExpression>>();
                        int branches = stmt.getInsertConditions().size();
                        for (int i = 0; i < branches; i++) {
                                TInsertCondition condition = stmt.getInsertConditions().getElement(i);
                                List<TExpression> governing = governingConditions(stmt, i);
                                for (int j = 0; j < condition.getInsertIntoValues().size(); j++) {
                                        intoClauses.add(condition.getInsertIntoValues().getElement(j));
                                        intoConditions.add(governing);
                                }
                        }
                        if (stmt.getElseIntoValues() != null) {
                                List<TExpression> governing = governingConditions(stmt, branches);
                                for (int j = 0; j < stmt.getElseIntoValues().size(); j++) {
                                        intoClauses.add(stmt.getElseIntoValues().getElement(j));
                                        intoConditions.add(governing);
                                }
                        }
                        for (int k = 0; k < intoClauses.size(); k++) {
                                TInsertIntoValue value = intoClauses.get(k);
                                TTable table = value.getTable();
                                Table tableModel = modelFactory.createTable(table);
                                if (mapsItsOwnColumns(value)) {
                                        selfMappedIntoClauses.add(new SelfMappedInto(tableModel, value, insertIntoTargets(tableModel, value),
                                                        k, intoConditions.get(k)));
                                        tableModel.addProcess(modelFactory.createProcess(stmt));
                                        continue;
                                }

                                inserTables.add(tableModel);
                                plainIntoConditions.put(inserTables.size() - 1, new Pair<Integer, List<TExpression>>(k, intoConditions.get(k)));
                                List<TObjectName> keyMap = new ArrayList<TObjectName>();
                                List<TResultColumn> valueMap = new ArrayList<TResultColumn>();
                                insertTableKeyMap.put(tableModel, keyMap);
                                insertTableValueMap.put(tableModel, valueMap);

                                List<TableColumn> tableColumns = bindInsertTableColumn(tableModel, value, keyMap, valueMap);
                                if (tableColumnMap.get(tableModel) == null
                                                && !tableColumns.isEmpty()) {
                                        tableColumnMap.put(tableModel,
                                                        tableColumns);
                                }

                                // if (stmt.getSubQuery() != null)
                                {
                                        Process process = modelFactory.createProcess(stmt);
                                        tableModel.addProcess(process);
                                }
                        }
                        hasInsertColumns = true;
                } else if (stmt.getInsertIntoValues() != null && stmt.getInsertIntoValues().size() > 0) {
                        for (int i = 0; i < stmt.getInsertIntoValues().size(); i++) {
                                TInsertIntoValue value = stmt.getInsertIntoValues().getElement(i);
                                TTable table = value.getTable();
                                Table tableModel = modelFactory.createTable(table);
                                if (mapsItsOwnColumns(value)) {
                                        selfMappedIntoClauses.add(new SelfMappedInto(tableModel, value, insertIntoTargets(tableModel, value), i,
                                                        Collections.<TExpression>emptyList()));
                                        tableModel.addProcess(modelFactory.createProcess(stmt));
                                        continue;
                                }

                                inserTables.add(tableModel);
                                List<TObjectName> keyMap = new ArrayList<TObjectName>();
                                List<TResultColumn> valueMap = new ArrayList<TResultColumn>();
                                insertTableKeyMap.put(tableModel, keyMap);
                                insertTableValueMap.put(tableModel, valueMap);

                                List<TableColumn> tableColumns = bindInsertTableColumn(tableModel, value, keyMap, valueMap);
                                if (tableColumnMap.get(tableModel) == null && !tableColumns.isEmpty()) {
                                        tableColumnMap.put(tableModel, tableColumns);
                                }

                                // if (stmt.getSubQuery() != null)
                                {
                                        Process process = modelFactory.createProcess(stmt);
                                        tableModel.addProcess(process);
                                }
                        }
                        hasInsertColumns = true;
                } else if (stmt.getColumnList() != null && stmt.getColumnList().size() > 0) {
                        TTable table = stmt.getTargetTable();
                        Table tableModel = modelFactory.createTable(table);

                        inserTables.add(tableModel);
                        List<TObjectName> keyMap = new ArrayList<TObjectName>();
                        insertTableKeyMap.put(tableModel, keyMap);
                        List<TableColumn> tableColumns = new ArrayList<TableColumn>();
                        for (int i = 0; i < stmt.getColumnList().size(); i++) {
                                TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                stmt.getColumnList().getObjectName(i));
                                tableColumns.add(tableColumn);
                        }
                        if (tableColumnMap.get(tableModel) == null && !tableColumns.isEmpty()) {
                                tableColumnMap.put(tableModel, tableColumns);
                        }

                        // if (stmt.getSubQuery() != null)
                        {
                                Process process = modelFactory.createProcess(stmt);
                                tableModel.addProcess(process);
                        }
                        hasInsertColumns = true;
                } else if (stmt.getOutputClause() != null && stmt.getOutputClause().getSelectItemList().size() > 0) {
                        TTable table = stmt.getTargetTable();
                        Table tableModel = modelFactory.createTable(table);

                        inserTables.add(tableModel);
                        List<TObjectName> keyMap = new ArrayList<TObjectName>();
                        insertTableKeyMap.put(tableModel, keyMap);
                        List<TableColumn> tableColumns = new ArrayList<TableColumn>();
                        for (int i = 0; i < stmt.getOutputClause().getSelectItemList().size(); i++) {
                                TObjectName columnName = stmt.getOutputClause().getSelectItemList().getResultColumn(i).getFieldAttr();
                                if (columnName.getPseudoTableType() != EPseudoTableType.none) {
                                        // Phase 1 already swapped tokens; getColumnNameOnly() returns actual column name
                                        String column = columnName.getColumnNameOnly();
                                        columnName = new TObjectName();
                                        columnName.setString(column);
                                } else {
                                        String column = columnName.toString().toLowerCase(Locale.ROOT);
                                        if ((column.startsWith("inserted.") || column.startsWith("deleted."))
                                                        && columnName.getPropertyToken() != null) {
                                                column = columnName.getPropertyToken().getAstext();
                                                columnName = new TObjectName();
                                                columnName.setString(column);
                                        }
                                }
                                TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel, columnName);
                                tableColumns.add(tableColumn);
                        }
                        if (tableColumnMap.get(tableModel) == null && !tableColumns.isEmpty()) {
                                tableColumnMap.put(tableModel, tableColumns);
                        }

                        // if (stmt.getSubQuery() != null)
                        {
                                Process process = modelFactory.createProcess(stmt);
                                tableModel.addProcess(process);
                        }
                        hasInsertColumns = true;
                } else {
                        TTable table = stmt.getTargetTable();
                        Table tableModel;
                        if (table != null) {
                                tableModel = modelFactory.createTable(table);
                                // if (stmt.getSubQuery() != null)
                                {
                                        Process process = modelFactory.createProcess(stmt);
                                        tableModel.addProcess(process);
                                }
                                if (tableModel.getColumns() == null || tableModel.getColumns().isEmpty()) {
                                        tableModel.addColumnsFromSQLEnv();
                                }
                        } else if (stmt.getDirectoryName() != null) {
                                tableModel = modelFactory.createTableByName(stmt.getDirectoryName(), true);
                                tableModel.setPath(true);
                                tableModel.setCreateTable(true);
                                TObjectName fileUri = new TObjectName();
                                fileUri.setString("uri=" + stmt.getDirectoryName());
                                TableColumn tableColumn = modelFactory.createFileUri(tableModel, fileUri);
                                // if (stmt.getSubQuery() != null)
                                {
                                        Process process = modelFactory.createProcess(stmt);
                                        tableModel.addProcess(process);
                                }
                        } else {
                                ErrorInfo errorInfo = new ErrorInfo();
                                errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                                errorInfo.setErrorMessage("Can't get target table. InsertSqlStatement is " + stmt.toString());
                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(stmt.getStartToken().lineNo,
                                                stmt.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(stmt.getEndToken().lineNo,
                                                stmt.getEndToken().columnNo + stmt.getEndToken().getAstext().length(),
                                                ModelBindingManager.getGlobalHash()));
                                errorInfo.fillInfo(this);
                                errorInfos.add(errorInfo);
                                return;
                        }
                        inserTables.add(tableModel);
                        if (table != null
                                        && tableColumnMap.get(tableModel) == null) {
                                if (tableModel.getColumns() != null && !tableModel.getColumns().isEmpty()) {
                                        tableColumnMap.put(tableModel,
                                                        tableModel.getColumns());
                                } else {
                                        tableColumnMap.put(tableModel, null);
                                }
                        }
                }

                if (stmt.getSubQuery() != null) {
                        analyzeSelectStmt(stmt.getSubQuery());
                }

                Set<Table> filteredTables = new HashSet<Table>();
                for (SelfMappedInto into : selfMappedIntoClauses) {
                        List<TableColumn> targets = analyzeInsertIntoClause(stmt, into, effectType, filteredTables.add(into.table));
                        if (!into.conditions.isEmpty()) {
                                whenScopes.add(new WhenScope(into.position, targets, into.conditions));
                        }
                }

                // what the per-table mapping below writes for an INTO clause of a conditional INSERT, for its WHEN impact
                Set<Relationship> relationsBefore = null;
                Table capturedTable = null;
                Pair<Integer, List<TExpression>> capturedInto = null;
                int tableIndex = -1;
                Iterator<Table> tableIter = inserTables.iterator();
                while (tableIter.hasNext()) {
                        if (capturedInto != null) {
                                whenScopes.add(new WhenScope(capturedInto.first, columnsWrittenSince(relationsBefore, capturedTable),
                                                capturedInto.second));
                                capturedInto = null;
                        }
                        Table tableModel = tableIter.next();
                        tableIndex++;
                        Pair<Integer, List<TExpression>> intoConditionsOfTable = plainIntoConditions.get(tableIndex);
                        if (intoConditionsOfTable != null && !intoConditionsOfTable.second.isEmpty()) {
                                relationsBefore = relationSnapshot();
                                capturedTable = tableModel;
                                capturedInto = intoConditionsOfTable;
                        }
                        List<TableColumn> tableColumns = tableColumnMap.get(tableModel);
                        List<TObjectName> keyMap = insertTableKeyMap.get(tableModel);
                        List<TResultColumn> valueMap = insertTableValueMap.get(tableModel);
                        boolean initColumn = (hasInsertColumns && tableColumns != null && !containStarColumn(tableColumns));

                        if (stmt.getSubQuery() != null) {

                                List<TSelectSqlStatement> subquerys = new ArrayList<TSelectSqlStatement>();
                                if (stmt.getSubQuery().getResultColumnList() != null || stmt.getSubQuery().getTransformClause() != null) {
                                        subquerys.add(stmt.getSubQuery());
                                } else if (stmt.getSubQuery().getValueClause() != null
                                                && stmt.getSubQuery().getValueClause().getRows() != null) {
                                        for (TResultColumnList resultColumnList : stmt.getSubQuery().getValueClause().getRows()) {
                                                for(TResultColumn resultColumn: resultColumnList) {
                                                        if(resultColumn.getExpr()!=null && resultColumn.getExpr().getSubQuery()!=null) {
                                                                analyzeSelectStmt(resultColumn.getExpr().getSubQuery());
                                                                subquerys.add(resultColumn.getExpr().getSubQuery());
                                                        }
                                                }
                                        }
                                }

                                for(TSelectSqlStatement subquery: subquerys) {
                                        if ((tableModel.isCreateTable() && tableModel.getColumns() != null)
                                                        || (subquery.getSetOperatorType() == ESetOperatorType.none
                                                                        && stmt.getColumnList() != null && stmt.getColumnList().size() > 0)) {

                                                ResultSet resultSetModel = null;

                                                if (subquery != null) {
                                                        resultSetModel = (ResultSet) modelManager.getModel(subquery);
                                                }

                                                TResultColumnList resultset = subquery.getResultColumnList();
                                                if (resultSetModel == null && resultset != null) {
                                                        resultSetModel = (ResultSet) modelManager.getModel(resultset);
                                                }

                                                if (resultSetModel == null) {
                                                        ErrorInfo errorInfo = new ErrorInfo();
                                                        errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                                                        errorInfo.setErrorMessage("Can't get resultset model");
                                                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(resultset.getStartToken().lineNo,
                                                                        resultset.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                                                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(resultset.getEndToken().lineNo,
                                                                        resultset.getEndToken().columnNo + resultset.getEndToken().getAstext().length(),
                                                                        ModelBindingManager.getGlobalHash()));
                                                        errorInfos.add(errorInfo);
                                                }

                                                if (!resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                        impactRelation.setEffectType(effectType);
                                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                        resultSetModel.getRelationRows()));
                                                        impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                        tableModel.getRelationRows()));
                                                }

                                                int resultSetSize = resultSetModel.getColumns().size();
                                                int j = 0;
                                                int starIndex = 0;
                                                TObjectNameList items = stmt.getColumnList();
                                                List<String> itemNames = new ArrayList<String>();
                                                int starColumnCount = 0;
                                                for (ResultColumn item : resultSetModel.getColumns()) {
                                                        if (item.isStarColumn()) {
                                                                starColumnCount += 1;
                                                        }
                                                }
                                                // a set operation with a star of unknown width: each listed column reads, from each of its
                                                // selects, the items that can stand at its position (Mantis 4914)
                                                List<SelectPositions> setSelects = items != null && subquery.isCombinedQuery()
                                                                ? setOperationPositions(subquery, items.size()) : null;
                                                if (items != null && (setSelects != null || starColumnCount > 1)) {
                                                        // Same undetermined mapping as the branch below, for an INSERT that names its
                                                        // target columns: the listed columns are the target positions, and more than
                                                        // one unknown-width wildcard leaves it unknown which of them feeds which.
                                                        // a select item that builds a STRUCT is one item, all of its fields (rule R8)
                                                        List<SelectPositions> selects = setSelects != null ? setSelects
                                                                        : Collections.singletonList(selectPositions(resultSetModel.getColumns(), items.size()));
                                                        for (int i = 0; i < items.size(); i++) {
                                                                TObjectName column = items.getObjectName(i);
                                                                if (column.getDbObjectType() == EDbObjectType.variable) {
                                                                        continue;
                                                                }
                                                                if (column.getColumnNameOnly().startsWith("@")
                                                                                && (option.getVendor() == EDbVendor.dbvmssql
                                                                                                || option.getVendor() == EDbVendor.dbvazuresql)) {
                                                                        continue;
                                                                }
                                                                if (column.getColumnNameOnly().startsWith(":")
                                                                                && (option.getVendor() == EDbVendor.dbvhana
                                                                                                || option.getVendor() == EDbVendor.dbvteradata)) {
                                                                        continue;
                                                                }
                                                                if (!hasCandidates(selects, i)) {
                                                                        continue;
                                                                }
                                                                TableColumn tableColumn = matchColumn(tableModel.getColumns(), column);
                                                                if (tableColumn == null) {
                                                                        if (tableModel.isCreateTable() && !containStarColumn(tableModel.getColumns())) {
                                                                                if (tableModel.getColumns().size() <= i) {
                                                                                        continue;
                                                                                }
                                                                                tableColumn = tableModel.getColumns().get(i);
                                                                        } else {
                                                                                tableColumn = modelFactory.createTableColumn(tableModel, column, false);
                                                                                if (tableColumn == null) {
                                                                                        continue;
                                                                                }
                                                                        }
                                                                }
                                                                feedSelectPositions(tableColumn, selects, i, effectType, modelFactory.createProcess(stmt));
                                                        }
                                                } else if (items != null) {
                                                        for (int i = 0; i < items.size() && j < resultSetSize; i++) {
                                                                TObjectName column = items.getObjectName(i);

                                                                if (column.getDbObjectType() == EDbObjectType.variable) {
                                                                        continue;
                                                                }

                                                                if (column.getColumnNameOnly().startsWith("@")
                                                                                && (option.getVendor() == EDbVendor.dbvmssql
                                                                                                || option.getVendor() == EDbVendor.dbvazuresql)) {
                                                                        continue;
                                                                }

                                                                if (column.getColumnNameOnly().startsWith(":")
                                                                                && (option.getVendor() == EDbVendor.dbvhana
                                                                                                || option.getVendor() == EDbVendor.dbvteradata)) {
                                                                        continue;
                                                                }

                                                                ResultColumn resultColumn = resultSetModel.getColumns().get(j);
                                                                List<ResultColumn> structItem = null;
                                                                if (!resultSetModel.getColumns().get(j).isStarColumn()) {
                                                                        // a select item that builds a STRUCT is one position, all of its fields (rule R8)
                                                                        int width = selectItemWidth(resultSetModel.getColumns(), j);
                                                                        if (width > 1 || structFieldPaths.containsKey(resultColumn)) {
                                                                                structItem = new ArrayList<ResultColumn>(
                                                                                                resultSetModel.getColumns().subList(j, j + width));
                                                                        }
                                                                        j += width;
                                                                } else {
                                                                        starIndex++;
                                                                        if (selectItemsFrom(resultSetModel.getColumns(), j, resultSetSize) == items.size() - i) {
                                                                                j++;

                                                                        }
                                                                }
                                                                if (column != null) {
                                                                        TableColumn tableColumn;
                                                                        // if (!initColumn) {
                                                                        tableColumn = matchColumn(tableModel.getColumns(), column);
                                                                        if (tableColumn == null) {
                                                                                if (tableModel.isCreateTable() && !containStarColumn(tableModel.getColumns())) {
                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                continue;
                                                                                        }
                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                } else {
                                                                                        tableColumn = modelFactory.createTableColumn(tableModel, column, false);
                                                                                        if(tableColumn == null) {
                                                                                                continue;
                                                                                        }
                                                                                }
                                                                        }
//                                                      } else {
//                                                              tableColumn = matchColumn(tableColumns, column);
//                                                              if (tableColumn == null) {
//                                                                      continue;
//                                                              }
//                                                      }
                                                                        if (structItem != null) {
                                                                                // the select list is as wide as the column list, so behind one star of unknown
                                                                                // width the items after it still have proven positions (owner ruling 2026-10-07)
                                                                                feedFromStructItem(tableColumn, structItem, column, effectType,
                                                                                                modelFactory.createProcess(stmt), false);
                                                                                for (ResultColumn field : structItem) {
                                                                                        itemNames.add(field.getName());
                                                                                }
                                                                                continue;
                                                                        }
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(effectType);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        if (resultColumn.hasStarLinkColumn()
                                                                                        && resultColumn.starLinkCount() > starIndex - 1 && starColumnCount<=1) {
                                                                                boolean find = false;
                                                                                while (resultColumn.starLinkCount() > starIndex - 1) {
                                                                                        TObjectName name = resultColumn.getStarLinkColumnName(starIndex - 1);
                                                                                        if (itemNames.contains(name.toString())) {
                                                                                                starIndex++;
                                                                                                continue;
                                                                                        }
                                                                                        ResultColumn expandStarColumn = modelFactory
                                                                                                        .createResultColumn(resultSetModel, name, false);
                                                                                        relation.addSource(new ResultColumnRelationshipElement(expandStarColumn));
                                                                                        itemNames.add(resultColumn.getName());
                                                                                        find = true;
                                                                                        break;
                                                                                }
                                                                                if (!find) {
                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                        itemNames.add(resultColumn.getName());
                                                                                }
                                                                        } else {
                                                                                relation.addSource(insertListSource(resultColumn, subquery));
                                                                                itemNames.add(resultColumn.getName());
                                                                        }
                                                                        Process process = modelFactory.createProcess(stmt);
                                                                        relation.setProcess(process);
                                                                        // the fields a STRUCT column carries (rule R8, Codex review of phase 3)
                                                                        feedBuiltFieldNodes(tableColumn, resultColumn, effectType, process, false);
                                                                }
                                                        }
                                                } else {
                                                        // STRUCT tree: a select item that builds a STRUCT fills the declared fields of the column
                                                        List<TableColumn> columns = insertPositionalColumns(tableModel, resultSetModel.getColumns());
                                                        boolean structLeaves = columns != tableModel.getColumns();
                                                        // a set operation with a star of unknown width: each column reads, from each of its selects,
                                                        // the items that can stand at its position (Mantis 4914)
                                                        setSelects = !structLeaves && subquery.isCombinedQuery()
                                                                        ? setOperationPositions(subquery, columns.size()) : null;
                                                        if (columns.size() == 1 && tableModel.isPath()) {
                                                                for(int i=0;i<resultSetSize;i++) {
                                                                        ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(effectType);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableModel.getColumns().get(0)));
                                                                        if (resultColumn.hasStarLinkColumn()
                                                                                        && resultColumn.starLinkCount() > starIndex - 1) {
                                                                                ResultColumn expandStarColumn = modelFactory.createResultColumn(
                                                                                                resultSetModel, resultColumn.getStarLinkColumnName(starIndex - 1),
                                                                                                false);
                                                                                relation.addSource(new ResultColumnRelationshipElement(expandStarColumn));
                                                                        } else {
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        }
                                                                        Process process = modelFactory.createProcess(stmt);
                                                                        relation.setProcess(process);
                                                                }
                                                        } else if (setSelects != null || starColumnCount > 1) {
                                                                // More than one wildcard of unknown width: the boundary between them is
                                                                // unknown, so no ordinal can say which one feeds which declared target
                                                                // column (see candidateSelectItems). Relate each target column to every
                                                                // select item that could supply it, and never to an expanded name picked
                                                                // by ordinal out of a partial expansion.
                                                                // a select item that builds a STRUCT is one item, all of its fields (rule R8)
                                                                List<SelectPositions> selects = setSelects != null ? setSelects
                                                                                : Collections.singletonList(selectPositions(resultSetModel.getColumns(), columns.size()));
                                                                for (int i = 0; i < columns.size(); i++) {
                                                                        if (columns.get(i).getName() == null) {
                                                                                continue;
                                                                        }
                                                                        TableColumn tableColumn = (structLeaves ? columns.get(i) : matchColumn(tableModel.getColumns(), columns.get(i)));
                                                                        if (tableColumn == null) {
                                                                                if (tableModel.getColumns().size() <= i) {
                                                                                        continue;
                                                                                }
                                                                                tableColumn = tableModel.getColumns().get(i);
                                                                        }
                                                                        if (!hasCandidates(selects, i)) {
                                                                                continue;
                                                                        }
                                                                        feedSelectPositions(tableColumn, selects, i, effectType, modelFactory.createProcess(stmt));
                                                                }
                                                        } else {
                                                                boolean fromStruct = false;
                                                                for (int i = 0; i < columns.size() && j < resultSetSize; i++) {
                                                                        String column = columns.get(i).getName();
                                                                        ResultColumn resultColumn = resultSetModel.getColumns().get(j);
                                                                        // a select item that builds a STRUCT is one position, all of its fields (rule R8),
                                                                        // unless the declared leaves of the target take its fields one by one
                                                                        List<ResultColumn> structItem = null;
                                                                        if (!resultColumn.isStarColumn()) {
                                                                                if (resultColumn.getName().equals(resultColumn.getRefColumnName())
                                                                                                && isStarNode(resultColumn.getColumnObject())
                                                                                                && resultSetSize == 1) {
                                                                                        starIndex++;
                                                                                        if (resultSetSize - j == columns.size() - i) {
                                                                                                j++;

                                                                                        }
                                                                                }
                                                                                else {
                                                                                        int width = structLeaves ? 1 : selectItemWidth(resultSetModel.getColumns(), j);
                                                                                        if (!structLeaves && (width > 1 || structFieldPaths.containsKey(resultColumn))) {
                                                                                                structItem = new ArrayList<ResultColumn>(
                                                                                                                resultSetModel.getColumns().subList(j, j + width));
                                                                                        }
                                                                                        j += width;
                                                                                }
                                                                        } else {
                                                                                starIndex++;
                                                                                int remaining = structLeaves ? resultSetSize - j
                                                                                                : selectItemsFrom(resultSetModel.getColumns(), j, resultSetSize);
                                                                                if (remaining == columns.size() - i) {
                                                                                        j++;

                                                                                }
                                                                        }
                                                                        if (column != null) {
                                                                                TableColumn tableColumn;
                                                                                // if (!initColumn) {
                                                                                tableColumn = (structLeaves ? columns.get(i) : matchColumn(tableModel.getColumns(), columns.get(i)));
                                                                                if (tableColumn == null) {
                                                                                        if (tableModel.isCreateTable()
                                                                                                        && !containStarColumn(tableModel.getColumns())) {
                                                                                                if (tableModel.getColumns().size() <= i) {
                                                                                                        continue;
                                                                                                }
                                                                                                tableColumn = tableModel.getColumns().get(i);
                                                                                        } else {
                                                                                                TObjectName columnName = new TObjectName();
                                                                                                columnName.setString(column);
                                                                                                tableColumn = modelFactory.createTableColumn(tableModel, columnName,
                                                                                                                false);
                                                                                        }
                                                                                }
                                                                                else if (structItem == null && !resultColumn.isStruct() && tableColumn.isStruct()
                                                                                                && columns.size() != resultSetSize) {
                                                                                        j--;
                                                                                        fromStruct = true;
                                                                                }
                                                                                if (structItem != null && tableColumn != null) {
                                                                                        // behind a star of unknown width too: the select list is as wide as the
                                                                                        // table, so the items after the star fill its last columns (owner ruling
                                                                                        // 2026-10-07)
                                                                                        feedFromStructItem(tableColumn, structItem, tableColumn.getColumnObject(),
                                                                                                        effectType, modelFactory.createProcess(stmt), false);
                                                                                        continue;
                                                                                }
                                                                                if(fromStruct && !tableColumn.isStruct()) {
                                                                                        fromStruct = false;
                                                                                        resultColumn = resultSetModel.getColumns().get(j);
                                                                                        j++;
                                                                                }
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(effectType);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                if (unknownOrderStar(resultColumn)) {
                                                                                        // a star of unknown column order: neither the member at the target's ordinal
                                                                                        // nor one named like it is the target's (Mantis 4860)
                                                                                        relation.addSource(positionSource(resultColumn));
                                                                                } else if (resultColumn.hasStarLinkColumn()
                                                                                                && resultColumn.starLinkCount() > starIndex - 1) {
                                                                                        ResultColumn expandStarColumn = modelFactory.createResultColumn(
                                                                                                        resultSetModel, resultColumn.getStarLinkColumnName(starIndex - 1),
                                                                                                        false);
                                                                                        relation.addSource(new ResultColumnRelationshipElement(expandStarColumn));
                                                                                } else {
                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn, starIndex - 1));
                                                                                }
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                                // the fields a STRUCT column carries (rule R8, Codex review of phase 3)
                                                                                feedBuiltFieldNodes(tableColumn, resultColumn, effectType, process, false);
                                                                        }
                                                                }
                                                        }
                                                }
                                        } else if (!subquery.isCombinedQuery()) {
                                                SelectResultSet resultSetModel = (SelectResultSet) modelManager
                                                                .getModel(subquery.getResultColumnList() != null ? subquery.getResultColumnList()
                                                                                : subquery.getTransformClause());

                                                if (resultSetModel != null && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                        impactRelation.setEffectType(effectType);
                                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                        resultSetModel.getRelationRows()));
                                                        impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                        tableModel.getRelationRows()));
                                                }

                                                List<ResultColumn> columnsSnapshot = new ArrayList<ResultColumn>();
                                                columnsSnapshot.addAll(resultSetModel.getColumns());
                                                if(resultSetModel.isDetermined() && stmt.getColumnList() == null) {
                                                        tableModel.setDetermined(true);
                                                }
                                                for (int i = 0; i < columnsSnapshot.size(); i++) {
                                                        ResultColumn resultColumn = columnsSnapshot.get(i);
                                                        if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                                TableColumn tableColumn;
                                                                if (!initColumn) {
                                                                        if (tableModel.isCreateTable() && !containStarColumn(tableModel.getColumns())) {
                                                                                if (tableModel.getColumns().size() <= i) {
                                                                                        continue;
                                                                                }
                                                                                tableColumn = tableModel.getColumns().get(i);
                                                                        } else {
                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                (TObjectName) resultColumn.getColumnObject());
                                                                                tableColumn.inheritIdentifier(resultColumn);
                                                                        }
                                                                        if (containStarColumn(tableColumns)) {
                                                                                getStarColumn(tableColumns)
                                                                                                .bindStarLinkColumn((TObjectName) resultColumn.getColumnObject());
                                                                        }
                                                                } else {
                                                                        TObjectName matchedColumnName = (TObjectName) resultColumn.getColumnObject();
                                                                        tableColumn = matchColumn(tableColumns, matchedColumnName);
                                                                        if (tableColumn == null) {
                                                                                if (!isEmptyCollection(valueMap)) {
                                                                                        int index = indexOfColumn(valueMap, matchedColumnName);
                                                                                        if (index != -1) {
                                                                                                if (!isEmptyCollection(keyMap) && index < keyMap.size()) {
                                                                                                        tableColumn = matchColumn(tableColumns, keyMap.get(index));
                                                                                                } else if (isEmptyCollection(keyMap) && index < tableColumns.size()) {
                                                                                                        tableColumn = tableColumns.get(index);
                                                                                                } else {
                                                                                                        continue;
                                                                                                }
                                                                                        } else {
                                                                                                continue;
                                                                                        }
                                                                                } else if (!isEmptyCollection(keyMap) && i < keyMap.size()) {
                                                                                        tableColumn = matchColumn(tableColumns, keyMap.get(i));
                                                                                } else if (isEmptyCollection(keyMap) && isEmptyCollection(valueMap)
                                                                                                && i < tableColumns.size()) {
                                                                                        tableColumn = tableColumns.get(i);
                                                                                } else {
                                                                                        continue;
                                                                                }
                                                                        }
                                                                }

                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(effectType);
                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                Process process = modelFactory.createProcess(stmt);
                                                                relation.setProcess(process);
                                                                feedBuiltFieldNodes(tableColumn, resultColumn, effectType, process, false);
                                                        } else {
                                                                TAliasClause alias = ((TResultColumn) resultColumn.getColumnObject()).getAliasClause();
                                                                if (alias != null && alias.getAliasName() != null) {
                                                                        TableColumn tableColumn;
                                                                        if (!initColumn) {
                                                                                if (tableModel.isCreateTable() && !containStarColumn(tableModel.getColumns())) {
                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                if (tableModel.isPath()) {
                                                                                                        tableColumn = tableModel.getColumns().get(0);
                                                                                                } else {
                                                                                                        continue;
                                                                                                }
                                                                                        } else {
                                                                                                tableColumn = tableModel.getColumns().get(i);
                                                                                        }
                                                                                } else {
                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                        alias.getAliasName());
                                                                                        if (containStarColumn(resultSetModel)) {
                                                                                                tableColumn.notBindStarLinkColumn(true);
                                                                                        }
                                                                                }
                                                                                if (containStarColumn(tableColumns)) {
                                                                                        getStarColumn(tableColumns).bindStarLinkColumn(alias.getAliasName());
                                                                                }
                                                                        } else {
                                                                                TObjectName matchedColumnName = alias.getAliasName();
                                                                                tableColumn = matchColumn(tableColumns, matchedColumnName);
                                                                                if (tableColumn == null) {
                                                                                        if (!isEmptyCollection(valueMap)) {
                                                                                                int index = indexOfColumn(valueMap, matchedColumnName);
                                                                                                if (index != -1) {
                                                                                                        if (!isEmptyCollection(keyMap) && index < keyMap.size()) {
                                                                                                                tableColumn = matchColumn(tableColumns, keyMap.get(index));
                                                                                                        } else if (isEmptyCollection(keyMap)
                                                                                                                        && index < tableColumns.size()) {
                                                                                                                tableColumn = tableColumns.get(index);
                                                                                                        } else {
                                                                                                                continue;
                                                                                                        }
                                                                                                } else {
                                                                                                        continue;
                                                                                                }
                                                                                        } else if (!isEmptyCollection(keyMap) && i < keyMap.size()) {
                                                                                                tableColumn = matchColumn(tableColumns, keyMap.get(i));
                                                                                        } else {
                                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                alias.getAliasName());
                                                                                        }
                                                                                }

                                                                        }

                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(effectType);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        Process process = modelFactory.createProcess(stmt);
                                                                        relation.setProcess(process);
                                                                        feedBuiltFieldNodes(tableColumn, resultColumn, effectType, process, false);

                                                                } else if (((TResultColumn) resultColumn.getColumnObject()).getFieldAttr() != null) {
                                                                        TObjectName fieldAttr = ((TResultColumn) resultColumn.getColumnObject())
                                                                                        .getFieldAttr();

                                                                        Object model = modelManager.getModel( resultColumn.getColumnObject());
                                                                        
                                                                        TableColumn tableColumn;
                                                                        if (!initColumn) {
                                                                                if (tableModel.isCreateTable() && !containStarColumn(tableModel.getColumns())) {
                                                                                        if (DlineageUtil.isStarName(fieldAttr)) {
                                                                                                int starIndex = 0;
                                                                                                for (TableColumn column : tableModel.getColumns()) {
                                                                                                        starIndex++;
                                                                                                        DataFlowRelationship relation = modelFactory
                                                                                                                        .createDataFlowRelation();
                                                                                                        relation.setEffectType(effectType);
                                                                                                        relation.setTarget(new TableColumnRelationshipElement(column));
                                                                                                        if (resultColumn.getStarLinkColumnList().size() == tableModel
                                                                                                                        .getColumns().size()) {
                                                                                                                ResultColumn expandStarColumn = modelFactory.createResultColumn(
                                                                                                                                resultSetModel,
                                                                                                                                resultColumn.getStarLinkColumnList().get(starIndex - 1),
                                                                                                                                false);
                                                                                                                relation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(expandStarColumn));
                                                                                                        } else {
                                                                                                                relation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(resultColumn));
                                                                                                        }
                                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                                        relation.setProcess(process);
                                                                                                }
                                                                                                continue;
                                                                                        }
                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                continue;
                                                                                        }
                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                } else {
                                                                                        if(model instanceof LinkedHashMap) {
                                                                                                LinkedHashMap<String, ResultColumn> resultColumns = (LinkedHashMap<String, ResultColumn>)model;
                                                                                                for(String key: resultColumns.keySet()) {
                                                                                                        tableColumn = itemColumnTarget(tableModel, resultColumns.get(key));
                                                                                                        DataFlowRelationship relation = modelFactory
                                                                                                                        .createDataFlowRelation();
                                                                                                        relation.setEffectType(effectType);
                                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                                        relation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(resultColumns.get(key)));
                                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                                        relation.setProcess(process);
                                                                                                }
                                                                                                continue;
                                                                                        }
                                                                                        else {
                                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel, fieldAttr);
                                                                                        }
                                                                                }
                                                                        } else if (tableModel.isDetermined() && i < tableModel.getColumns().size()) {
                                                                                if (!isEmptyCollection(valueMap)) {
                                                                                        TObjectName matchedColumnName = fieldAttr;
                                                                                        int index = indexOfColumn(valueMap, matchedColumnName);
                                                                                        if (index != -1) {
                                                                                                if (!isEmptyCollection(keyMap) && index < keyMap.size()) {
                                                                                                        tableColumn = matchColumn(tableColumns, keyMap.get(index));
                                                                                                } else if (isEmptyCollection(keyMap)
                                                                                                                && index < tableColumns.size()) {
                                                                                                        tableColumn = tableColumns.get(index);
                                                                                                } else {
                                                                                                        continue;
                                                                                                }
                                                                                        } else {
                                                                                                continue;
                                                                                        }
                                                                                } else if (!isEmptyCollection(keyMap) && i < keyMap.size()) {
                                                                                        tableColumn = matchColumn(tableColumns, keyMap.get(i));
                                                                                } else {
                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                }
                                                                        } else {
                                                                                TObjectName matchedColumnName = fieldAttr;
                                                                                tableColumn = matchColumn(tableColumns, matchedColumnName);
                                                                                if (tableColumn == null) {
                                                                                        if (!isEmptyCollection(valueMap)) {
                                                                                                int index = indexOfColumn(valueMap, matchedColumnName);
                                                                                                if (index != -1) {
                                                                                                        if (!isEmptyCollection(keyMap) && index < keyMap.size()) {
                                                                                                                tableColumn = matchColumn(tableColumns, keyMap.get(index));
                                                                                                        } else if (isEmptyCollection(keyMap)
                                                                                                                        && index < tableColumns.size()) {
                                                                                                                tableColumn = tableColumns.get(index);
                                                                                                        } else {
                                                                                                                continue;
                                                                                                        }
                                                                                                } else {
                                                                                                        continue;
                                                                                                }
                                                                                        } else if (!isEmptyCollection(keyMap) && i < keyMap.size()) {
                                                                                                tableColumn = matchColumn(tableColumns, keyMap.get(i));
                                                                                        } else {
                                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                fieldAttr);
                                                                                        }
                                                                                }
                                                                        }

                                                                        if (!DlineageUtil.isStarName((tableColumn.getColumnObject()))
                                                                                        && DlineageUtil.isStarName((fieldAttr))) {
                                                                                TObjectName columnObject = fieldAttr;
                                                                                TTable sourceTable = columnObject.getSourceTable();
                                                                                if (columnObject.getTableToken() != null && sourceTable != null) {
                                                                                        TObjectName[] columns = modelManager.getTableColumns(sourceTable);
                                                                                        for (int j = 0; j < columns.length; j++) {
                                                                                                TObjectName columnName = columns[j];
                                                                                                if (columnName == null || DlineageUtil.isStarName((columnName))) {
                                                                                                        continue;
                                                                                                }
                                                                                                resultColumn.bindStarLinkColumn(columnName);
                                                                                        }
                                                                                } else {
                                                                                        TTableList tables = stmt.getTables();
                                                                                        for (int k = 0; k < tables.size(); k++) {
                                                                                                TTable tableElement = tables.getTable(k);
                                                                                                TObjectName[] columns = modelManager.getTableColumns(tableElement);
                                                                                                for (int j = 0; j < columns.length; j++) {
                                                                                                        TObjectName columnName = columns[j];
                                                                                                        if (columnName == null || DlineageUtil.isStarName((columnName))) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        resultColumn.bindStarLinkColumn(columnName);
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }

                                                                        if (DlineageUtil.isStarName((tableColumn.getColumnObject())) && resultColumn != null
                                                                                        && resultColumn.hasStarLinkColumn()) {
                                                                                tableColumn.shareStarLinksFrom(resultColumn);
                                                                        }

                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(effectType);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));

                                                                        if (tableColumn.isStarColumn() && resultColumn.isStarColumn()) {
                                                                                tableColumn.getTable().setStarStmt("insert");
                                                                        }

                                                                        Process process = modelFactory.createProcess(stmt);
                                                                        relation.setProcess(process);
                                                                } else if (((TResultColumn) resultColumn.getColumnObject()).getExpr()
                                                                                .getExpressionType() == EExpressionType.simple_constant_t) {
                                                                        if (!initColumn) {
                                                                                TableColumn tableColumn;
                                                                                if (tableModel.isCreateTable() && !containStarColumn(tableModel.getColumns())) {
                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                continue;
                                                                                        }
                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                } else {
                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                        ((TResultColumn) resultColumn.getColumnObject()).getExpr()
                                                                                                                        .getConstantOperand(),
                                                                                                        i);
                                                                                }

                                                                                if (DlineageUtil.isTempTable(tableModel, option.getVendor()) && sqlenv != null
                                                                                                && tableModel.getDatabase() != null && tableModel.getSchema() != null) {
                                                                                        TSQLSchema schema = tableMetadataEnvironment(tableModel).getSQLSchema(
                                                                                                        tableModel.getDatabase() + "." + tableModel.getSchema(), true);
                                                                                        if (schema != null) {
                                                                                                TSQLTable tempTable = schema.createTable(
                                                                                                                DlineageUtil.getSimpleTableName(tableModel.getName()));
                                                                                                if (tableColumn.isStarColumn()) {
                                                                                                        addUnresolvedStar(tempTable);
                                                                                                } else {
                                                                                                        tempTable.addColumn(tableColumn.getName());
                                                                                                }
                                                                                        }
                                                                                }
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(effectType);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                        } else {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(effectType);
                                                                                relation.setTarget(
                                                                                                new TableColumnRelationshipElement(tableModel.getColumns().get(i)));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                        }
                                                                } else {
                                                                        if (!initColumn) {
                                                                                TableColumn tableColumn;
                                                                                if (tableModel.isCreateTable() && !containStarColumn(tableModel.getColumns())) {
                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                continue;
                                                                                        }
                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                } else {
                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                        ((TResultColumn) resultColumn.getColumnObject()).getExpr(), i);
                                                                                }
                                                                                if (DlineageUtil.isTempTable(tableModel, option.getVendor()) && sqlenv != null
                                                                                                && tableModel.getDatabase() != null && tableModel.getSchema() != null) {
                                                                                        TSQLSchema schema = tableMetadataEnvironment(tableModel).getSQLSchema(
                                                                                                        tableModel.getDatabase() + "." + tableModel.getSchema(), true);
                                                                                        if (schema != null) {
                                                                                                TSQLTable tempTable = schema.createTable(
                                                                                                                DlineageUtil.getSimpleTableName(tableModel.getName()));
                                                                                                if (tableColumn.isStarColumn()) {
                                                                                                        addUnresolvedStar(tempTable);
                                                                                                } else {
                                                                                                        tempTable.addColumn(tableColumn.getName());
                                                                                                }
                                                                                        }
                                                                                }
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(effectType);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                        } else {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(effectType);
                                                                                relation.setTarget(
                                                                                                new TableColumnRelationshipElement(tableModel.getColumns().get(i)));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                        }
                                                                }
                                                        }
                                                }
                                        } else if (stmt.getSubQuery() != null) {
                                                ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt.getSubQuery());
                                                if (resultSetModel != null) {

                                                        if (!resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                                impactRelation.setEffectType(effectType);
                                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                                resultSetModel.getRelationRows()));
                                                                impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                                tableModel.getRelationRows()));
                                                        }

                                                        // a star of unknown width in a select: each listed column reads, from each select, the items that
                                                        // can stand at its position (Mantis 4914)
                                                        List<SelectPositions> setSelects = stmt.getColumnList() != null && stmt.getColumnList().size() > 0
                                                                        ? setOperationPositions(stmt.getSubQuery(), stmt.getColumnList().size()) : null;
                                                        if (setSelects != null) {
                                                                for (int i = 0; i < stmt.getColumnList().size(); i++) {
                                                                        TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                        stmt.getColumnList().getObjectName(i));
                                                                        if (tableColumn != null && hasCandidates(setSelects, i)) {
                                                                                feedSelectPositions(tableColumn, setSelects, i, effectType, modelFactory.createProcess(stmt));
                                                                        }
                                                                }
                                                        } else if(stmt.getColumnList()!=null && stmt.getColumnList().size()>0) {
                                                                for(int i=0;i<stmt.getColumnList().size();i++) {
                                                                        TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                        stmt.getColumnList().getObjectName(i));
                                                                }
                                                                
                                                                List<TableColumn> columns = tableModel.getColumns();
                                                                int resultSetSize = resultSetModel.getColumns().size();
                                                                int starIndex = 0; 
                                                                int j = 0;
                                                                boolean fromStruct = false;
                                                                for (int i = 0; i < columns.size() && j < resultSetSize; i++) {
                                                                        String column = columns.get(i).getName();
                                                                        ResultColumn resultColumn = resultSetModel.getColumns().get(j);
                                                                        if (!resultColumn.isStarColumn()) {
                                                                                if (resultColumn.getName().equals(resultColumn.getRefColumnName())
                                                                                                && isStarNode(resultColumn.getColumnObject())
                                                                                                && resultSetSize == 1) {
                                                                                        starIndex++;
                                                                                        if (resultSetSize - j == columns.size() - i) {
                                                                                                j++;

                                                                                        }
                                                                                }
                                                                                else {
                                                                                        j++;
                                                                                }
                                                                        } else {
                                                                                starIndex++;
                                                                                if (resultSetSize - j == columns.size() - i) {
                                                                                        j++;

                                                                                }
                                                                        }
                                                                        if (column != null) {
                                                                                TableColumn tableColumn;
                                                                                // if (!initColumn) {
                                                                                tableColumn = matchColumn(tableModel.getColumns(), columns.get(i));
                                                                                if (tableColumn == null) {
                                                                                        if (tableModel.isCreateTable()
                                                                                                        && !containStarColumn(tableModel.getColumns())) {
                                                                                                if (tableModel.getColumns().size() <= i) {
                                                                                                        continue;
                                                                                                }
                                                                                                tableColumn = tableModel.getColumns().get(i);
                                                                                        } else {
                                                                                                TObjectName columnName = new TObjectName();
                                                                                                columnName.setString(column);
                                                                                                tableColumn = modelFactory.createTableColumn(tableModel, columnName,
                                                                                                                false);
                                                                                        }
                                                                                }
                                                                                else if (!resultColumn.isStruct() && tableColumn.isStruct() && columns.size() != resultSetSize) {
                                                                                        j--;
                                                                                        fromStruct = true;
                                                                                }
                                                                                if(fromStruct && !tableColumn.isStruct()) {
                                                                                        fromStruct = false;
                                                                                        resultColumn = resultSetModel.getColumns().get(j);
                                                                                        j++;
                                                                                }
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(effectType);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                if (resultColumn.hasStarLinkColumn()
                                                                                                && resultColumn.starLinkCount() > starIndex - 1) {
                                                                                        ResultColumn expandStarColumn = modelFactory.createResultColumn(
                                                                                                        resultSetModel, resultColumn.getStarLinkColumnName(starIndex - 1),
                                                                                                        false);
                                                                                        relation.addSource(new ResultColumnRelationshipElement(expandStarColumn));
                                                                                } else {
                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn, starIndex - 1));
                                                                                }
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                                // the fields a STRUCT column carries (rule R8, Codex review of phase 3)
                                                                                feedBuiltFieldNodes(tableColumn, resultColumn, effectType, process, false);
                                                                        }
                                                                }
                                                        }
                                                        else {
                                                                for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                                                        ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                                                        TAliasClause alias = null;
                                                                        if(resultColumn.getColumnObject() instanceof TResultColumn) {
                                                                                alias = ((TResultColumn) resultColumn.getColumnObject()).getAliasClause();
                                                                        }
                                                                        if (stmt.getColumnList() != null) {
                                                                                if (i < stmt.getColumnList().size()) {
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(effectType);
                                                                                        TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                        stmt.getColumnList().getObjectName(i));
                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                }
                                                                        } else {
                                                                                if (alias != null && alias.getAliasName() != null) {
                                                                                        TableColumn tableColumn;
                                                                                        if (!initColumn) {
                                                                                                if (tableModel.isCreateTable()
                                                                                                                && !containStarColumn(tableModel.getColumns())) {
                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                } else {
                                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                        alias.getAliasName());
                                                                                                }
                                                                                        } else {
                                                                                                tableColumn = matchColumn(tableColumns, alias.getAliasName());
                                                                                                if (tableColumn == null) {
                                                                                                        continue;
                                                                                                }
                                                                                        }
        
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(effectType);
                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                } else if (resultColumn.getColumnObject() instanceof TObjectName 
                                                                                                || ( resultColumn.getColumnObject() instanceof TResultColumn && ((TResultColumn) resultColumn.getColumnObject())
                                                                                                .getFieldAttr() != null)) {
                                                                                        TObjectName fieldAttr = null;
                                                                                        if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                                                                fieldAttr = (TObjectName)resultColumn.getColumnObject();
                                                                                        }
                                                                                        else if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                                                                                fieldAttr = ((TResultColumn) resultColumn.getColumnObject())
                                                                                                                .getFieldAttr();
                                                                                        }
                                
                                                                                        TableColumn tableColumn;
                                                                                        if (!initColumn) {
                                                                                                if (tableModel.isCreateTable()
                                                                                                                && !containStarColumn(tableModel.getColumns())) {
                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                } else {
                                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                        fieldAttr);
                                                                                                        tableColumn.inheritIdentifier(resultColumn);
                                                                                                }
                                                                                        } else {
                                                                                                tableColumn = matchColumn(tableColumns, fieldAttr);
                                                                                                if (tableColumn == null) {
                                                                                                        continue;
                                                                                                }
                                                                                        }
        
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(effectType);
                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                } else if (((TResultColumn) resultColumn.getColumnObject()).getExpr()
                                                                                                .getExpressionType() == EExpressionType.simple_constant_t) {
                                                                                        if (!initColumn) {
                                                                                                TableColumn tableColumn;
                                                                                                if (tableModel.isCreateTable()
                                                                                                                && !containStarColumn(tableModel.getColumns())) {
                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                } else {
                                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                        ((TResultColumn) resultColumn.getColumnObject()).getExpr()
                                                                                                                                        .getConstantOperand(),
                                                                                                                        i);
                                                                                                }
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(effectType);
                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                relation.setProcess(process);
                                                                                        }
                                                                                } else {
                                                                                        if (!initColumn) {
                                                                                                TableColumn tableColumn;
                                                                                                if (tableModel.isCreateTable()
                                                                                                                && !containStarColumn(tableModel.getColumns())) {
                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                } else {
                                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                        ((TResultColumn) resultColumn.getColumnObject()).getExpr(), i);
                                                                                                }
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(effectType);
                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                relation.setProcess(process);
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        } else if (stmt.getColumnList() != null && stmt.getColumnList().size() > 0) {
                                TObjectNameList items = stmt.getColumnList();
                                TMultiTargetList values = stmt.getValues();
                                if (values != null) {
                                        for (int k = 0; values != null && k < values.size(); k++) {
                                                int j = 0;
                                                for (int i = 0; i < items.size(); i++) {
                                                        TObjectName column = items.getObjectName(i);
                                                        TableColumn tableColumn;
                                                        if (!initColumn) {
                                                                if (tableModel.isCreateTable() && !containStarColumn(tableModel.getColumns())) {
                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                continue;
                                                                        }
                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                } else {
                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel, column);
                                                                }
                                                        } else {
                                                                tableColumn = matchColumn(tableColumns, column);
                                                                if (tableColumn == null) {
                                                                        continue;
                                                                }
                                                        }
                                                        TResultColumn columnObject = values.getMultiTarget(k).getColumnList().getResultColumn(j);
                                                        if (columnObject == null) {
                                                                continue;
                                                        }
                                                        TExpression valueExpr = columnObject.getExpr();
                                                        columnsInExpr visitor = new columnsInExpr();
                                                        valueExpr.inOrderTraverse(visitor);
                                                        List<TObjectName> objectNames = visitor.getObjectNames();
                                                        List<TParseTreeNode> constants = visitor.getConstants();
                                                        List<TParseTreeNode> functions = visitor.getFunctions();
                                                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                                        Process process = modelFactory.createProcess(stmt);



                                                        if (functions != null && !functions.isEmpty()) {
                                                                analyzeFunctionDataFlowRelation(tableColumn, functions, effectType, process);
                                                        }

                                                        if (subquerys != null && !subquerys.isEmpty()) {
                                                                analyzeSubqueryDataFlowRelation(tableColumn, subquerys, effectType, process);
                                                        }
                                                        if (objectNames != null && !objectNames.isEmpty()) {
                                                                analyzeDataFlowRelation(tableColumn, objectNames, null, effectType, functions,
                                                                                process, i);
                                                        }
                                                        //insert into values generate too many constant relations, ignore constant relations.
                                                        if (constants != null && !constants.isEmpty()) {
                                                                if (!option.isIgnoreInsertIntoValues() || stmt.getParentStmt() != null) {
                                                                        analyzeConstantDataFlowRelation(tableColumn, constants, effectType,
                                                                                        functions, process);
                                                                }
                                                        }
                                                        j++;
                                                }
                                        }
                                } else if (stmt.getExecuteStmt() != null && stmt.getExecuteStmt().getModuleName() != null) {
                                        analyzeCustomSqlStmt(stmt.getExecuteStmt());
                                        Procedure procedure = modelManager.getProcedure(nameAliasKey(stmt.getExecuteStmt().getModuleName(), null));
                                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("insertExec", stmt.getExecuteStmt().getModuleName(), procedure, new Integer[] {null}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.PROCEDURE);
                                        if ((procedure != null && procedure.getProcedureObject() instanceof TStoredProcedureSqlStatement)
                                                        || isSpExecuteExternalScript(stmt.getExecuteStmt().getModuleName())) {
                                                List<ResultSet> resultSetModels = calleeResultSetsForInsertExec(stmt.getExecuteStmt(), procedure);
                                                if (resultSetModels != null) {
                                                        for (ResultSet resultSetModel : resultSetModels) {
                                                                if (resultSetModel != null) {
                                                                        for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                                                                ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                                                                Transform transform = new Transform();
                                                                                transform.setType(Transform.FUNCTION);
                                                                                transform.setCode(stmt.getExecuteStmt().getModuleName());
                                                                                resultColumn.setTransform(transform);
                                                                                
                                                                                if (stmt.getColumnList() != null) {
                                                                                        if (i < stmt.getColumnList().size()) {
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(effectType);
                                                                                                TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                stmt.getColumnList().getObjectName(i));                                                                                         
                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                relation.setProcess(process);                                   
                                                                                        }
                                                                                } else {
                                                                                        if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                                                                TObjectName fieldAttr = ((TObjectName) resultColumn.getColumnObject());
                                                                                                TableColumn tableColumn;
                                                                                                if (!initColumn) {
                                                                                                        if (tableModel.isCreateTable()
                                                                                                                        && !containStarColumn(tableModel.getColumns())) {
                                                                                                                if (tableModel.getColumns().size() <= i) {
                                                                                                                        continue;
                                                                                                                }
                                                                                                                tableColumn = tableModel.getColumns().get(i);
                                                                                                        } else {
                                                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                                fieldAttr);
                                                                                                        }
                                                                                                } else {
                                                                                                        tableColumn = matchColumn(tableColumns, fieldAttr);
                                                                                                        if (tableColumn == null) {
                                                                                                                continue;
                                                                                                        }
                                                                                                }
        
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(effectType);
                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                relation.setProcess(process);

                                                                                                
                                                                                        } else {
                                                                                                TAliasClause alias = ((TResultColumn) resultColumn.getColumnObject())
                                                                                                                .getAliasClause();
                                                                                                if (alias != null && alias.getAliasName() != null) {
                                                                                                        TableColumn tableColumn;
                                                                                                        if (!initColumn) {
                                                                                                                if (tableModel.isCreateTable()
                                                                                                                                && !containStarColumn(tableModel.getColumns())) {
                                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                                continue;
                                                                                                                        }
                                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                                } else {
                                                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                                        alias.getAliasName());
                                                                                                                }
                                                                                                        } else {
                                                                                                                tableColumn = matchColumn(tableColumns, alias.getAliasName());
                                                                                                                if (tableColumn == null) {
                                                                                                                        continue;
                                                                                                                }
                                                                                                        }
                                                                                                        
                                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                        relation.setEffectType(effectType);
                                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                                        relation.setProcess(process);
                                                                                                } else if (((TResultColumn) resultColumn.getColumnObject())
                                                                                                                .getFieldAttr() != null) {
                                                                                                        TObjectName fieldAttr = ((TResultColumn) resultColumn.getColumnObject())
                                                                                                                        .getFieldAttr();
                                                                                                        TableColumn tableColumn;
                                                                                                        if (!initColumn) {
                                                                                                                if (tableModel.isCreateTable()
                                                                                                                                && !containStarColumn(tableModel.getColumns())) {
                                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                                continue;
                                                                                                                        }
                                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                                } else {
                                                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                                        fieldAttr);
                                                                                                                }
                                                                                                        } else {
                                                                                                                tableColumn = matchColumn(tableColumns, fieldAttr);
                                                                                                                if (tableColumn == null) {
                                                                                                                        continue;
                                                                                                                }
                                                                                                        }
                                                                                                        
                                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                        relation.setEffectType(effectType);
                                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                                        relation.setProcess(process);                                                                                                   
                                                                                                } else if (((TResultColumn) resultColumn.getColumnObject()).getExpr()
                                                                                                                .getExpressionType() == EExpressionType.simple_constant_t) {
                                                                                                        if (!initColumn) {
                                                                                                                TableColumn tableColumn;
                                                                                                                if (tableModel.isCreateTable()
                                                                                                                                && !containStarColumn(tableModel.getColumns())) {
                                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                                continue;
                                                                                                                        }
                                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                                } else {
                                                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                                        ((TResultColumn) resultColumn.getColumnObject()).getExpr()
                                                                                                                                                        .getConstantOperand(),
                                                                                                                                        i);
                                                                                                                }
                                                                                                                
                                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                relation.setEffectType(effectType);
                                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                                relation.setProcess(process);
                                                                                                        }
                                                                                                } else {
                                                                                                        if (!initColumn) {
                                                                                                                TableColumn tableColumn;
                                                                                                                if (tableModel.isCreateTable()
                                                                                                                                && !containStarColumn(tableModel.getColumns())) {
                                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                                continue;
                                                                                                                        }
                                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                                } else {
                                                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                                        ((TResultColumn) resultColumn.getColumnObject()).getExpr(),
                                                                                                                                        i);
                                                                                                                }
                                                                                                                
                                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                relation.setEffectType(effectType);
                                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                                relation.setProcess(process);
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                        else if (procedure!=null && procedure.getProcedureObject() instanceof TObjectName) {
                                                TObjectName functionName = new TObjectName();
                                                functionName.setString(procedure.getName());
                                                Function function = (Function)createFunction(functionName);
                                                // The name above is display text with no tokens: the result stands for this routine.
                                                function.setAliasKey(procedure.getAliasKey());
                                                if (stmt.getColumnList() != null) {
                                                        for (int i = 0; i < stmt.getColumnList().size(); i++) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(effectType);
                                                                TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                stmt.getColumnList().getObjectName(i));
                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(function.getColumns().get(0)));
                                                                Process process = modelFactory.createProcess(stmt);
                                                                relation.setProcess(process);
                                                        }
                                                }
                                        }
                                } else if (stmt.getExecuteStmt() != null) {
                                        // INSERT INTO t EXEC(@sql) / EXEC('...'): the string form has no module name,
                                        // so the branch above never saw it - no dynamic site was recorded and the
                                        // inner statement was never analyzed. Analyze the EXEC like its top-level
                                        // twin (site + inner lineage); the INSERT target itself stays unlinked.
                                        analyzeCustomSqlStmt(stmt.getExecuteStmt());
                                }
                        } else if (stmt.getValues() != null && stmt.getValues().size() > 0 && tableModel.isCreateTable() && !tableModel.getColumns().isEmpty()) {
                                for (int k = 0; stmt.getValues() != null && k < stmt.getValues().size(); k++) {
                                        TResultColumnList columns = stmt.getValues().getMultiTarget(k).getColumnList();
                                        boolean allConstant = true;
                                        Process process = modelFactory.createProcess(stmt);
                                        int columnSize = tableModel.getColumns().size();
                                        for (int x = 0; x < columns.size(); x++) {
                                                if (x >= columnSize) {
                                                        break;
                                                }
                                                TableColumn tableColumn = tableModel.getColumns().get(x);
                                                TResultColumn columnObject = columns.getResultColumn(x);
                                                if (columnObject == null) {
                                                        continue;
                                                }
                                                TExpression valueExpr = columnObject.getExpr();
                                                columnsInExpr visitor = new columnsInExpr();
                                                valueExpr.inOrderTraverse(visitor);
                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                List<TParseTreeNode> constants = visitor.getConstants();
                                                List<TParseTreeNode> functions = visitor.getFunctions();
                                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                                if (functions != null && !functions.isEmpty()) {
                                                        analyzeFunctionDataFlowRelation(tableColumn, functions, effectType, process);
                                                        allConstant = false;
                                                }

                                                if (subquerys != null && !subquerys.isEmpty()) {
                                                        analyzeSubqueryDataFlowRelation(tableColumn, subquerys, effectType, process);
                                                        allConstant = false;
                                                }
                                                if (objectNames != null && !objectNames.isEmpty()) {
                                                        analyzeDataFlowRelation(tableColumn, objectNames, null, effectType, functions,
                                                                        process);
                                                        allConstant = false;
                                                }
                                                //insert into values generate too many constant relations, ignore constant relations.
                                                if (constants != null && !constants.isEmpty() && stmt.getParentStmt() != null) {
                                                        analyzeConstantDataFlowRelation(tableColumn, constants, effectType, functions,
                                                                        process);
                                                        allConstant = false;
                                                }
                                        }
                                        
                                        if(allConstant) {
                                                modelManager.unbindProcessModel(stmt);
                                                tableModel.removeProcess(process);
                                        }
                                }
                        } else if (stmt.getRecordName() != null) {
                                // The record INSERT ... VALUES rec names.
                                Table recordTable = modelManager.visibleLocal(withoutColon(stmt.getRecordName().toString()),
                                                LocalSymbolKey.Kind.VARIABLE);
                                if (recordTable != null) {
                                        // Oracle fills the table by position. A record declared as a row of this very table has the
                                        // table's columns as its fields, in order, so each field fills the column of its name; any other
                                        // record is still paired by its fields' own names, which position does not bear out.
                                        boolean rowOfTarget = recordTable instanceof Variable
                                                        && ((Variable) recordTable).getRowTypeAnchor() == tableModel;
                                        for (int i = 0; i < recordTable.getColumns().size(); i++) {
                                                TableColumn sourceTableColumn = recordTable.getColumns().get(i);
                                                TObjectName field = sourceTableColumn.getColumnObject();
                                                TableColumn targetTableColumn = modelFactory.createTableColumn(tableModel,
                                                                rowOfTarget ? recordFieldColumnName(field) : field, false);
                                                if (targetTableColumn != null) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(effectType);
                                                        relation.setTarget(new TableColumnRelationshipElement(targetTableColumn));
                                                        relation.addSource(new TableColumnRelationshipElement(sourceTableColumn));
                                                        Process process = modelFactory.createProcess(stmt);
                                                        relation.setProcess(process);
                                                } else if (sourceTableColumn.isStarColumn() && tableModel.isCreateTable()) {
                                                        for (TableColumn column : tableModel.getColumns()) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(effectType);
                                                                relation.setTarget(new TableColumnRelationshipElement(column));
                                                                relation.addSource(new TableColumnRelationshipElement(sourceTableColumn));
                                                                Process process = modelFactory.createProcess(stmt);
                                                                relation.setProcess(process);
                                                        }
                                                }
                                        }
                                }
                        } else if (stmt.getInsertSource() == EInsertSource.values_function && stmt.getFunctionCall() != null) {
                                // The collection or cursor VALUES f(...) names; else a table of that name.
                                Table cursor = modelManager.visibleLocal(stmt.getFunctionCall().getFunctionName().toString(),
                                                LocalSymbolKey.Kind.CURSOR);
                                if (cursor == null) {
                                        cursor = modelManager.getTableByName(
                                                        DlineageUtil.getTableIdentityKey(stmt.getFunctionCall().getFunctionName().toString()));
                                }
                                if (cursor != null) {
                                        TObjectName starColumn = DlineageUtil.syntheticStarName();
                                        TableColumn insertColumn = modelFactory.createTableColumn(tableModel, starColumn, true);
                                        insertColumn.setShowStar(false);
                                        insertColumn.setExpandStar(true);
                                        for (int j = 0; j < cursor.getColumns().size(); j++) {
                                                DataFlowRelationship dataflowRelation = modelFactory.createDataFlowRelation();
                                                dataflowRelation.setEffectType(effectType);
                                                dataflowRelation.addSource(new TableColumnRelationshipElement(cursor.getColumns().get(j)));
                                                dataflowRelation.setTarget(new TableColumnRelationshipElement(insertColumn));
                                                Process process = modelFactory.createProcess(stmt);
                                                dataflowRelation.setProcess(process);
                                        }
                                }

                        } else if (stmt.getInsertSource() == EInsertSource.values && stmt.getValues() != null) {
                                TObjectName starColumn = DlineageUtil.syntheticStarName();
                                TableColumn insertColumn = modelFactory.createTableColumn(tableModel, starColumn, true);
                                insertColumn.setShowStar(false);
                                insertColumn.setExpandStar(true);
                                for (int k = 0; stmt.getValues() != null && k < stmt.getValues().size(); k++) {
                                        TResultColumnList columns = stmt.getValues().getMultiTarget(k).getColumnList();
                                        for (int x = 0; x < columns.size(); x++) {
                                                TResultColumn columnObject = columns.getResultColumn(x);
                                                if (columnObject == null) {
                                                        continue;
                                                }
                                                TExpression valueExpr = columnObject.getExpr();
                                                columnsInExpr visitor = new columnsInExpr();
                                                valueExpr.inOrderTraverse(visitor);
                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                List<TParseTreeNode> constants = visitor.getConstants();
                                                List<TParseTreeNode> functions = visitor.getFunctions();
                                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                                Process process = modelFactory.createProcess(stmt);
                                                if (functions != null && !functions.isEmpty()) {
                                                        analyzeFunctionDataFlowRelation(insertColumn, functions, effectType, process);
                                                }

                                                if (subquerys != null && !subquerys.isEmpty()) {
                                                        analyzeSubqueryDataFlowRelation(insertColumn, subquerys, effectType, process);
                                                }
                                                if (objectNames != null && !objectNames.isEmpty()) {
                                                        analyzeDataFlowRelation(insertColumn, objectNames, null, effectType, functions,
                                                                        process);
                                                }
                                                //insert into values generate too many constant relations, ignore constant relations.
                                                if (constants != null && !constants.isEmpty() && stmt.getParentStmt() != null) {
                                                        analyzeConstantDataFlowRelation(insertColumn, constants, effectType, functions,
                                                                        process);
                                                }
                                        }
                                }
                        }else if (stmt.getExecuteStmt() != null && stmt.getExecuteStmt().getModuleName() != null) {
                                analyzeCustomSqlStmt(stmt.getExecuteStmt());
                                Procedure procedure = modelManager.getProcedure(nameAliasKey(stmt.getExecuteStmt().getModuleName(), null));
                                if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("insertExec", stmt.getExecuteStmt().getModuleName(), procedure, new Integer[] {null}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.PROCEDURE);
                                if ((procedure != null && procedure.getProcedureObject() instanceof TStoredProcedureSqlStatement)
                                                || isSpExecuteExternalScript(stmt.getExecuteStmt().getModuleName())) {
                                        List<ResultSet> resultSetModels = calleeResultSetsForInsertExec(stmt.getExecuteStmt(), procedure);
                                        if (resultSetModels != null) {
                                                for (ResultSet resultSetModel : resultSetModels) {
                                                        if (resultSetModel != null) {
                                                                for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                                                        ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                                                        
                                                                        Transform transform = new Transform();
                                                                        transform.setType(Transform.FUNCTION);
                                                                        transform.setCode(stmt.getExecuteStmt().getModuleName());
                                                                        resultColumn.setTransform(transform);
                                                                        
                                                                        TAliasClause alias = null;

                                                                        if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                                                                alias = ((TResultColumn) resultColumn.getColumnObject())
                                                                                                .getAliasClause();
                                                                        }
                                                                        
                                                                        if (alias != null && alias.getAliasName() != null) {
                                                                                TableColumn tableColumn;
                                                                                if (!initColumn) {
                                                                                        if (tableModel.isCreateTable()
                                                                                                        && !containStarColumn(tableModel.getColumns())) {
                                                                                                if(resultColumn.isStarColumn()) {
                                                                                                        for(TableColumn tableColumnItem: tableModel.getColumns()) {
                                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                relation.setEffectType(effectType);
                                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumnItem));
                                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                                relation.setProcess(process);
                                                                                                        }
                                                                                                        continue;
                                                                                                }
                                                                                                else {
                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                }
                                                                                        } else {
                                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                alias.getAliasName());
                                                                                        }
                                                                                } else {
                                                                                        tableColumn = matchColumn(tableColumns, alias.getAliasName());
                                                                                        if (tableColumn == null) {
                                                                                                continue;
                                                                                        }
                                                                                }
                                        
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(effectType);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                        } else if (resultColumn.getColumnObject() instanceof TObjectName
                                                                                        || (resultColumn.getColumnObject() instanceof TResultColumn
                                                                                                        && ((TResultColumn) resultColumn.getColumnObject())
                                                                                                                        .getFieldAttr() != null)) {
                                                                                TObjectName fieldAttr = null;
                                                                                if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                                                        fieldAttr = (TObjectName) resultColumn.getColumnObject();
                                                                                } else {
                                                                                        fieldAttr = ((TResultColumn) resultColumn.getColumnObject()).getFieldAttr();
                                                                                }
                                                                                TableColumn tableColumn;
                                                                                if (!initColumn) {
                                                                                        if (tableModel.isCreateTable()
                                                                                                        && !containStarColumn(tableModel.getColumns())) {
                                                                                                if(resultColumn.isStarColumn()) {
                                                                                                        for(TableColumn tableColumnItem: tableModel.getColumns()) {
                                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                relation.setEffectType(effectType);
                                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumnItem));
                                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                                relation.setProcess(process);
                                                                                                        }
                                                                                                        continue;
                                                                                                }
                                                                                                else {
                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                }
                                                                                        } else {
                                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                fieldAttr);
                                                                                        }
                                                                                } else {
                                                                                        tableColumn = matchColumn(tableColumns, fieldAttr);
                                                                                        if (tableColumn == null) {
                                                                                                continue;
                                                                                        }
                                                                                }
                                                                                
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(effectType);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                relation.setProcess(process);
                                                                        } else if (((TResultColumn) resultColumn.getColumnObject()).getExpr()
                                                                                        .getExpressionType() == EExpressionType.simple_constant_t) {
                                                                                if (!initColumn) {
                                                                                        TableColumn tableColumn;
                                                                                        if (tableModel.isCreateTable()
                                                                                                        && !containStarColumn(tableModel.getColumns())) {
                                                                                                if(resultColumn.isStarColumn()) {
                                                                                                        for(TableColumn tableColumnItem: tableModel.getColumns()) {
                                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                relation.setEffectType(effectType);
                                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumnItem));
                                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                                relation.setProcess(process);
                                                                                                        }
                                                                                                        continue;
                                                                                                }
                                                                                                else {
                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                }
                                                                                        } else {
                                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                ((TResultColumn) resultColumn.getColumnObject()).getExpr()
                                                                                                                                .getConstantOperand(),
                                                                                                                i);
                                                                                        }
                                                                                        
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(effectType);
                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                }
                                                                        } else {
                                                                                if (!initColumn) {
                                                                                        TableColumn tableColumn;
                                                                                        if (tableModel.isCreateTable()
                                                                                                        && !containStarColumn(tableModel.getColumns())) {
                                                                                                if(resultColumn.isStarColumn()) {
                                                                                                        for(TableColumn tableColumnItem: tableModel.getColumns()) {
                                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                relation.setEffectType(effectType);
                                                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumnItem));
                                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                Process process = modelFactory.createProcess(stmt);
                                                                                                                relation.setProcess(process);
                                                                                                        }
                                                                                                        continue;
                                                                                                }
                                                                                                else {
                                                                                                        if (tableModel.getColumns().size() <= i) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        tableColumn = tableModel.getColumns().get(i);
                                                                                                }
                                                                                        } else {
                                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                                ((TResultColumn) resultColumn.getColumnObject()).getExpr(),
                                                                                                                i);
                                                                                        }
                                                                                        
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(effectType);
                                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                                else if (procedure!=null && procedure.getProcedureObject() instanceof TObjectName) {
                                        TObjectName functionName = new TObjectName();
                                        functionName.setString(procedure.getName());
                                        Function function = (Function)createFunction(functionName);
                                        // The name above is display text with no tokens: the result stands for this routine.
                                        function.setAliasKey(procedure.getAliasKey());
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(effectType);
                                        TObjectName starColumn = DlineageUtil.syntheticStarName();
                                        TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                        starColumn);
                                        tableColumn.setExpandStar(false);
                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                        relation.addSource(new ResultColumnRelationshipElement(function.getColumns().get(0)));
                                        Process process = modelFactory.createProcess(stmt);
                                        relation.setProcess(process);
                                }
                        } else if (stmt.getExecuteStmt() != null) {
                                // INSERT INTO t EXEC(@sql) / EXEC('...'): the string form has no module name,
                                // so the branch above never saw it - no dynamic site was recorded and the
                                // inner statement was never analyzed. Analyze the EXEC like its top-level
                                // twin (site + inner lineage); the INSERT target itself stays unlinked.
                                analyzeCustomSqlStmt(stmt.getExecuteStmt());
                        }
                }
                if (capturedInto != null) {
                        whenScopes.add(new WhenScope(capturedInto.first, columnsWrittenSince(relationsBefore, capturedTable),
                                        capturedInto.second));
                }
                
                if(stmt.getOnDuplicateKeyUpdate()!=null) {
                        TTable table = stmt.getTargetTable();
                        Table tableModel = modelFactory.createTable(table);
                        for(TResultColumn column: stmt.getOnDuplicateKeyUpdate()) {
                                if(column.getExpr()==null || column.getExpr().getExpressionType() != EExpressionType.assignment_t) {
                                        continue;
                                }
                                TExpression left = column.getExpr().getLeftOperand();
                                TExpression right = column.getExpr().getRightOperand();
                                TObjectName columnObject = left.getObjectOperand();
                                if (columnObject != null) {
                                        TableColumn tableColumn = modelFactory.createTableColumn(tableModel, columnObject, false);
                                        if (tableColumn != null) {
                                                columnsInExpr visitor = new columnsInExpr();
                                                right.inOrderTraverse(visitor);
                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                List<TParseTreeNode> functions = visitor.getFunctions();
                                                List<TParseTreeNode> constants = visitor.getConstants();
                                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                                if (functions != null && !functions.isEmpty()) {
                                                        analyzeFunctionDataFlowRelation(tableColumn, functions, EffectType.update);
                                                }
                                                if (subquerys != null && !subquerys.isEmpty()) {
                                                        analyzeSubqueryDataFlowRelation(tableColumn, subquerys, EffectType.update);
                                                }
                                                if (objectNames != null && !objectNames.isEmpty()) {
                                                        analyzeDataFlowRelation(tableColumn, objectNames, EffectType.update, functions);
                                                }
                                                if (constants != null && !constants.isEmpty()) {
                                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.update, functions);
                                                }
                                        }
                                }
                        }
                }

                if (!whenScopes.isEmpty() && stmt.getSubQuery() != null) {
                        Collections.sort(whenScopes, new Comparator<WhenScope>() {
                                @Override
                                public int compare(WhenScope a, WhenScope b) {
                                        return a.position < b.position ? -1 : (a.position == b.position ? 0 : 1);
                                }
                        });
                        TSelectSqlStatement subquery = stmt.getSubQuery();
                        Object model = modelManager.getModel(subquery);
                        if (!(model instanceof ResultSet) && subquery.getResultColumnList() != null) {
                                model = modelManager.getModel(subquery.getResultColumnList());
                        }
                        ResultSet subqueryRows = model instanceof ResultSet ? (ResultSet) model : null;
                        Map<TExpression, List<Pair<ResultColumn, TObjectName>>> conditionReads = new IdentityHashMap<TExpression, List<Pair<ResultColumn, TObjectName>>>();
                        for (WhenScope scope : whenScopes) {
                                analyzeInsertWhenImpact(subquery, subqueryRows, scope, conditionReads, effectType);
                        }
                }
        }

        /**
         * Check whether a SELECT statement actually returns a result set to the client.
         * A SELECT does NOT return a result set when:
         * <ul>
         *   <li>It has an INTO clause ({@code SELECT ... INTO @var})</li>
         *   <li>It has an INTO TABLE clause ({@code SELECT ... INTO TABLE t})</li>
         *   <li>All result columns are variable assignments ({@code SELECT @var = expr}) —
         *       MSSQL-only, detected via {@code EExpressionType.sqlserver_proprietary_column_alias_t}</li>
         * </ul>
         */
        private static boolean isResultSetReturningSelect(TSelectSqlStatement select) {
                if (select.getIntoClause() != null || select.getIntoTableClause() != null) {
                        return false;
                }
                if (select.getResultColumnList() != null && select.getResultColumnList().size() > 0) {
                        boolean allAssignments = true;
                        for (int i = 0; i < select.getResultColumnList().size(); i++) {
                                TResultColumn col = select.getResultColumnList().getResultColumn(i);
                                if (col.getExpr() == null
                                                || col.getExpr().getExpressionType() != EExpressionType.sqlserver_proprietary_column_alias_t) {
                                        allAssignments = false;
                                        break;
                                }
                        }
                        if (allAssignments) {
                                return false;
                        }
                }
                return true;
        }

        private List<TSelectSqlStatement> getLastSelectStmt(TStoredProcedureSqlStatement procedureStmt) {
                List<TSelectSqlStatement> stmts = new ArrayList<TSelectSqlStatement>();
                if (procedureStmt.getBodyStatements().size() > 0) {
                        for (int j = procedureStmt.getBodyStatements().size() - 1; j >= 0; j--) {
                                TCustomSqlStatement stmtItem = procedureStmt.getBodyStatements().get(j);
                                if (stmtItem instanceof TReturnStmt || stmtItem instanceof TMssqlReturn) {
                                        if (stmtItem.getStatements() != null) {
                                                List<TSelectSqlStatement> item = getLastSelectStmt(stmtItem);
                                                if (item != null && !item.isEmpty()) {
                                                        stmts.addAll(item);
                                                        if(option.getVendor()!=EDbVendor.dbvmssql && option.getVendor()!=EDbVendor.dbvazuresql) {
                                                                break;
                                                        }
                                                }
                                        }
                                        break;
                                }
                                if (stmtItem instanceof TSelectSqlStatement && !((TSelectSqlStatement) stmtItem).isQueryOfCTE()) {
                                        if (isResultSetReturningSelect((TSelectSqlStatement) stmtItem)) {
                                                if(!(DlineageUtil.getTopBasicStmt(stmtItem) instanceof TSelectSqlStatement)) {
                                                        continue;
                                                }
                                                stmts.add((TSelectSqlStatement) stmtItem);
                                                if(option.getVendor()!=EDbVendor.dbvmssql && option.getVendor()!=EDbVendor.dbvazuresql) {
                                                        break;
                                                }
                                        }
                                } else if (stmtItem.getStatements() != null) {
                                        List<TSelectSqlStatement> item = getLastSelectStmt(stmtItem);
                                        if (item != null && !item.isEmpty()) {
                                                stmts.addAll(item);
                                                if(option.getVendor()!=EDbVendor.dbvmssql && option.getVendor()!=EDbVendor.dbvazuresql) {
                                                        break;
                                                }
                                        }
                                }
                        }
                }
                return stmts;
        }

        private List<TSelectSqlStatement> getLastSelectStmt(TCustomSqlStatement stmt) {
                List<TSelectSqlStatement> stmts = new ArrayList<TSelectSqlStatement>();
                for (int j = stmt.getStatements().size() - 1; j >= 0; j--) {
                        TCustomSqlStatement stmtItem = stmt.getStatements().get(j);
                        if (stmtItem instanceof TReturnStmt || stmtItem instanceof TMssqlReturn) {
                                if (stmtItem.getStatements() != null) {
                                        List<TSelectSqlStatement> item = getLastSelectStmt(stmtItem);
                                        if (item != null && !item.isEmpty()) {
                                                stmts.addAll(item);
                                                if(option.getVendor()!=EDbVendor.dbvmssql && option.getVendor()!=EDbVendor.dbvazuresql) {
                                                        break;
                                                }
                                        }
                                }
                                break;
                        }
                        if (stmtItem instanceof TSelectSqlStatement && !((TSelectSqlStatement) stmtItem).isQueryOfCTE()) {
                                if (isResultSetReturningSelect((TSelectSqlStatement) stmtItem)) {
                                        if(!(DlineageUtil.getTopBasicStmt(stmtItem) instanceof TSelectSqlStatement)) {
                                                continue;
                                        }
                                        stmts.add((TSelectSqlStatement) stmtItem);
                                        if(option.getVendor()!=EDbVendor.dbvmssql && option.getVendor()!=EDbVendor.dbvazuresql) {
                                                break;
                                        }
                                }
                        } else if (stmtItem.getStatements() != null) {
                                List<TSelectSqlStatement> item = getLastSelectStmt(stmtItem);
                                if (item != null && !item.isEmpty()) {
                                        stmts.addAll(item);
                                        if(option.getVendor()!=EDbVendor.dbvmssql && option.getVendor()!=EDbVendor.dbvazuresql) {
                                                break;
                                        }
                                }
                        }
                }
                return stmts;
        }

        private TableColumn getStarColumn(List<TableColumn> columns) {
                for (TableColumn column : columns) {
                        if (column.isStarColumn()) {
                                return column;
                        }
                }
                return null;
        }

        private boolean containStarColumn(List<TableColumn> columns) {
                if (columns == null)
                        return false;
                for (TableColumn column : columns) {
                        if (column.isStarColumn()) {
                                return true;
                        }
                }
                return false;
        }

        private boolean containStarColumn(ResultSet resultSet) {
                if (resultSet == null || resultSet.getColumns() == null)
                        return false;
                for (ResultColumn column : resultSet.getColumns()) {
                        if (column.isStarColumn()) {
                                return true;
                        }
                }
                return false;
        }

        private int indexOfColumn(List<TResultColumn> columns, TObjectName objectName) {
                for (int i = 0; i < columns.size(); i++) {
                        if (columns.get(i).toString().trim().equalsIgnoreCase(objectName.toString().trim())) {
                                return i;
                        }
                }
                return -1;
        }

        private boolean isEmptyCollection(Collection<?> keyMap) {
                return keyMap == null || keyMap.isEmpty();
        }

        private void analyzeUpdateStmt(TUpdateSqlStatement stmt) {
                if (stmt.getResultColumnList() == null)
                        return;

                TTable targetTable = stmt.getTargetTable();
                Process process = modelFactory.createProcess(stmt);
                Table tableModel = null;
                QueryTable cteTargetModel = null;
                CteWriteTargetResolution cteTargetResolution = null;
                if (targetTable.getCTE() != null) {
                        cteTargetModel = analyzeCteWriteTarget(targetTable, process);
                        cteTargetResolution = resolveCteWriteTarget(targetTable, collectUpdateCteWriteIntent(stmt));
                        if (cteTargetResolution.isWritable()) {
                                tableModel = modelFactory.createTable(cteTargetResolution.baseTable);
                                tableModel.addProcess(process);
                                createProjectedWriteImpact(targetTable.getCTE().getSubquery(), tableModel,
                                                EffectType.update, process);
                        }
                        if (cteTargetResolution.failureReason != null) {
                                addCteWriteTargetHint(targetTable, cteTargetResolution.failureReason,
                                                cteTargetResolution.isWritable());
                        }
                } else if (targetTable.getSubquery() != null
                                || (targetTable.getLinkTable() != null
                                                && targetTable.getLinkTable().getSubquery() != null)) {
                        TTable projectedTarget = targetTable.getSubquery() != null
                                        ? targetTable : targetTable.getLinkTable();
                        TSelectSqlStatement projectedSubquery = projectedTarget.getSubquery();
                        TObjectNameList exposedColumns = getProjectedTargetColumns(projectedTarget);
                        cteTargetModel = analyzeProjectedWriteTarget(targetTable, projectedSubquery,
                                        exposedColumns, process);
                        cteTargetResolution = resolveProjectedWriteTarget(projectedSubquery, exposedColumns,
                                        collectUpdateCteWriteIntent(stmt));
                        if (cteTargetResolution.isWritable()) {
                                tableModel = modelFactory.createTable(cteTargetResolution.baseTable);
                                tableModel.addProcess(process);
                                createProjectedWriteImpact(projectedSubquery, tableModel, EffectType.update, process);
                        }
                        if (cteTargetResolution.failureReason != null) {
                                addCteWriteTargetHint(targetTable, cteTargetResolution.failureReason,
                                                cteTargetResolution.isWritable());
                        }
                } else {
                        tableModel = modelFactory.createTable(targetTable);
                        tableModel.addProcess(process);
                }

                for (int i = 0; i < stmt.tables.size(); i++) {
                        TTable tableElement = stmt.tables.getTable(i);
                        if (tableElement == targetTable && cteTargetModel != null) {
                                continue;
                        }
                        if (tableElement.getSubquery() != null) {
                                QueryTable queryTable = modelFactory.createQueryTable(tableElement);
                                TSelectSqlStatement subquery = tableElement.getSubquery();
                                analyzeSelectStmt(subquery);

                                if (subquery.getSetOperatorType() != ESetOperatorType.none) {
                                        SelectSetResultSet selectSetResultSetModel = (SelectSetResultSet) modelManager.getModel(subquery);
                                        for (int j = 0; j < selectSetResultSetModel.getColumns().size(); j++) {
                                                ResultColumn sourceColumn = selectSetResultSetModel.getColumns().get(j);
                                                ResultColumn targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                                DataFlowRelationship selectSetRalation = modelFactory.createDataFlowRelation();
                                                selectSetRalation.setEffectType(EffectType.select);
                                                selectSetRalation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                selectSetRalation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                                selectSetRalation.setProcess(process);
                                        }
                                }

                                ResultSet resultSetModel = (ResultSet) modelManager.getModel(tableElement.getSubquery());
                                if (resultSetModel != null && resultSetModel != queryTable
                                                && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.setEffectType(EffectType.update);
                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        resultSetModel.getRelationRows()));
                                        impactRelation.setTarget(
                                                        new RelationRowsRelationshipElement<ResultSetRelationRows>(queryTable.getRelationRows()));
                                }

                        } else if (tableElement.getCTE() != null) {
                                QueryTable queryTable = modelFactory.createQueryTable(tableElement);

                                TObjectNameList cteColumns = tableElement.getCTE().getColumnList();
                                if (cteColumns != null) {
                                        for (int j = 0; j < cteColumns.size(); j++) {
                                                modelFactory.createResultColumn(queryTable, cteColumns.getObjectName(j));
                                        }
                                }
                                TSelectSqlStatement subquery = tableElement.getCTE().getSubquery();
                                if (subquery != null && !stmtStack.contains(subquery)) {
                                        analyzeSelectStmt(subquery);

                                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(subquery);
                                        if (resultSetModel != null && resultSetModel != queryTable
                                                        && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(EffectType.select);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                resultSetModel.getRelationRows()));
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                queryTable.getRelationRows()));
                                        }

                                        if (resultSetModel == null) {
                                                // a CTE defined by VALUES has no result set model (Mantis 5010): reading it threw
                                                // NullPointerException
                                                if (subquery.getValueClause() != null) {
                                                        analyzeValuesCte(queryTable, subquery.getValueClause(), cteColumns, process);
                                                }
                                        } else if (cteColumns != null) {
                                                // a column list names positions, which a star of unknown width or a list shorter than the query
                                                // sets apart from the indexes of the items: each CTE column reads the items that can stand at its
                                                // position, from each select of a set operation, as a query reading the CTE does (Mantis 5003).
                                                // Pairing them one by one ran past a short list.
                                                List<SelectPositions> setSelects = subquery.getSetOperatorType() != ESetOperatorType.none
                                                                ? setOperationPositions(subquery, queryTable.getColumns().size(),
                                                                                shorterList(cteColumns, tableElement))
                                                                : null;
                                                mapCteColumnsByCandidates(queryTable, setSelects != null ? setSelects
                                                                : Collections.singletonList(selectPositions(resultSetModel.getColumns(),
                                                                                queryTable.getColumns().size(), shorterList(cteColumns, tableElement))),
                                                                cteColumns, process);
                                        } else if (subquery.getSetOperatorType() != ESetOperatorType.none) {
                                                SelectSetResultSet selectSetResultSetModel = (SelectSetResultSet) modelManager
                                                                .getModel(subquery);
                                                for (int j = 0; j < selectSetResultSetModel.getColumns().size(); j++) {
                                                        ResultColumn sourceColumn = selectSetResultSetModel.getColumns().get(j);
                                                        ResultColumn targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                                        for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                targetColumn.bindStarLinkColumn(starLinkColumn);
                                                        }
                                                        createCteSelectRelation(process, targetColumn, sourceColumn);
                                                }
                                        } else {
                                                for (int j = 0; j < resultSetModel.getColumns().size(); j++) {
                                                        ResultColumn sourceColumn = resultSetModel.getColumns().get(j);
                                                        ResultColumn targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                                        for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                targetColumn.bindStarLinkColumn(starLinkColumn);
                                                        }
                                                        createCteSelectRelation(process, targetColumn, sourceColumn);
                                                }
                                        }
                                } else if (tableElement.getCTE().getUpdateStmt() != null) {
                                        analyzeCustomSqlStmt(tableElement.getCTE().getUpdateStmt());
                                } else if (tableElement.getCTE().getInsertStmt() != null) {
                                        analyzeCustomSqlStmt(tableElement.getCTE().getInsertStmt());
                                } else if (tableElement.getCTE().getDeleteStmt() != null) {
                                        analyzeCustomSqlStmt(tableElement.getCTE().getDeleteStmt());
                                } else if (tableElement.getCTE().getMergeStmt() != null) {
                                        analyzeCustomSqlStmt(tableElement.getCTE().getMergeStmt());
                                }
                        } else {
                                modelFactory.createTable(stmt.tables.getTable(i));
                        }
                }

                for (int i = 0; i < stmt.getResultColumnList().size(); i++) {
                        TResultColumn field = stmt.getResultColumnList().getResultColumn(i);

                        if (field.getExpr().getExpressionType() == EExpressionType.function_t) {
                                // Handle SQL Server XML modify() method for data lineage
                                TFunctionCall funcCall = field.getExpr().getFunctionCall();
                                if (tableModel != null && funcCall != null
                                                && funcCall.getFunctionType() == EFunctionType.xmlmodify_t) {
                                        analyzeXmlModifyFunction(stmt, tableModel, process, funcCall);
                                }
                                continue;
                        }

                        TExpression expression = updateSetTarget(field.getExpr().getLeftOperand());
                        if (expression == null) {
                                ErrorInfo errorInfo = new ErrorInfo();
                                errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                                errorInfo.setErrorMessage(
                                                "Can't get result column expression. Expression is " + field.getExpr().toString());
                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(field.getExpr().getStartToken().lineNo,
                                                field.getExpr().getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(field.getExpr().getEndToken().lineNo,
                                                field.getExpr().getEndToken().columnNo + field.getExpr().getEndToken().getAstext().length(),
                                                ModelBindingManager.getGlobalHash()));
                                errorInfo.fillInfo(this);
                                errorInfos.add(errorInfo);
                                continue;
                        }
                        if (expression.getExpressionType() == EExpressionType.list_t) {
                                TExpression setExpression = field.getExpr().getRightOperand();
                                if (setExpression != null && setExpression.getSubQuery() != null) {
                                        TSelectSqlStatement query = setExpression.getSubQuery();
                                        analyzeSelectStmt(query);

                                        SelectResultSet resultSetModel = (SelectResultSet) modelManager
                                                        .getModel(query.getResultColumnList());

                                        if (resultSetModel != null && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(EffectType.update);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                resultSetModel.getRelationRows()));
                                                if (tableModel != null) {
                                                        impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                        tableModel.getRelationRows()));
                                                } else if (cteTargetModel != null) {
                                                        impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                        cteTargetModel.getRelationRows()));
                                                }
                                        }

                                        TExpressionList columnList = expression.getExprList();
                                        for (int j = 0; j < columnList.size(); j++) {
                                                TObjectName column = columnList.getExpression(j).getObjectOperand();

                                                if (column.getDbObjectType() == EDbObjectType.variable) {
                                                        continue;
                                                }

                                                if (column.getColumnNameOnly().startsWith("@") && (option.getVendor() == EDbVendor.dbvmssql
                                                                || option.getVendor() == EDbVendor.dbvazuresql)) {
                                                        continue;
                                                }

                                                if (column.getColumnNameOnly().startsWith(":") && (option.getVendor() == EDbVendor.dbvhana
                                                                || option.getVendor() == EDbVendor.dbvteradata)) {
                                                        continue;
                                                }

                                                TObjectName targetColumn = getCteBaseColumn(cteTargetResolution, column);
                                                TableColumn tableColumn = tableModel == null || targetColumn == null ? null
                                                                : modelFactory.createTableColumn(tableModel, targetColumn, false);
                                                if (resultSetModel == null) {
                                                        if (tableColumn != null && query.getValueClause() != null) {
                                                                analyzeUpdateSetValues(tableColumn, query.getValueClause(), j, process);
                                                        }
                                                        continue;
                                                }
                                                ResultColumn resultColumn = resultSetModel.getColumns().get(j);
                                                if (tableColumn != null) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.update);
                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.setProcess(process);
                                                }

                                        }
                                }
                        } else if (expression.getExpressionType() == EExpressionType.simple_object_name_t) {
                                TExpression setExpression = field.getExpr().getRightOperand();
                                if (setExpression != null && setExpression.getSubQuery() != null) {
                                        TSelectSqlStatement query = setExpression.getSubQuery();
                                        analyzeSelectStmt(query);

                                        SelectResultSet resultSetModel = (SelectResultSet) modelManager
                                                        .getModel(query.getResultColumnList());

                                        if (resultSetModel != null && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(EffectType.update);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                resultSetModel.getRelationRows()));
                                                if (tableModel != null) {
                                                        impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                        tableModel.getRelationRows()));
                                                } else if (cteTargetModel != null) {
                                                        impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                        cteTargetModel.getRelationRows()));
                                                }
                                        }

                                        TObjectName column = expression.getObjectOperand();
                                        TObjectName targetColumn = getCteBaseColumn(cteTargetResolution, column);
                                        TableColumn tableColumn = tableModel == null || targetColumn == null ? null
                                                        : modelFactory.createTableColumn(tableModel, targetColumn, false);
                                        if (resultSetModel == null) {
                                                if (tableColumn != null && query.getValueClause() != null) {
                                                        analyzeUpdateSetValues(tableColumn, query.getValueClause(), 0, process);
                                                }
                                        } else {
                                                ResultColumn resultColumn = resultSetModel.getColumns().get(0);
                                                if (tableColumn != null) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.update);
                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.setProcess(process);
                                                }
                                        }
                                } else if (setExpression != null) {
                                        // ResultSet resultSet = modelFactory.createResultSet(stmt,
                                        // true);

                                        ResultSet resultSet = modelFactory.createResultSet(stmt, false);

                                        createPseudoImpactRelation(stmt, resultSet, EffectType.update);

                                        TObjectName columnObject = expression.getObjectOperand();

                                        ResultColumn updateColumn = modelFactory.createUpdateResultColumn(resultSet, columnObject);

                                        columnsInExpr visitor = new columnsInExpr();
                                        field.getExpr().getRightOperand().inOrderTraverse(visitor);

                                        List<TObjectName> objectNames = visitor.getObjectNames();
                                        List<TParseTreeNode> functions = visitor.getFunctions();
                                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                        if (functions != null && !functions.isEmpty()) {
                                                analyzeFunctionDataFlowRelation(updateColumn, functions, EffectType.update);
                                        }

                                        if (subquerys != null && !subquerys.isEmpty()) {
                                                analyzeSubqueryDataFlowRelation(updateColumn, subquerys, EffectType.update);
                                        }

                                        Transform transform = new Transform();
                                        transform.setType(Transform.EXPRESSION);
                                        transform.setCode(setExpression);
                                        updateColumn.setTransform(transform);
                                        analyzeDataFlowRelation(updateColumn, objectNames, EffectType.update, functions);

                                        List<TParseTreeNode> constants = visitor.getConstants();
                                        analyzeConstantDataFlowRelation(updateColumn, constants, EffectType.update, functions);

                                        TObjectName targetColumn = getCteBaseColumn(cteTargetResolution, columnObject);
                                        TableColumn tableColumn = tableModel == null || targetColumn == null ? null
                                                        : modelFactory.createTableColumn(tableModel, targetColumn, false);
                                        if(tableColumn!=null) {
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.update);
                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                relation.addSource(new ResultColumnRelationshipElement(updateColumn));
                                                relation.setProcess(process);
                                        }
                                        
                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.setEffectType(EffectType.update);
                                        impactRelation.addSource(
                                                        new RelationRowsRelationshipElement<ResultSetRelationRows>(resultSet.getRelationRows()));
                                        if (tableModel != null) {
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                tableModel.getRelationRows()));
                                        } else if (cteTargetModel != null) {
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                cteTargetModel.getRelationRows()));
                                        }
                                }
                        } else {
                                addUnanalyzedSetAssignmentError("Unsupported UPDATE SET target", expression, field.getExpr());
                        }
                }

                if (stmt.getJoins() != null && stmt.getJoins().size() > 0) {
                        for (int i = 0; i < stmt.getJoins().size(); i++) {
                                TJoin join = stmt.getJoins().getJoin(i);
                                if (join.getJoinItems() != null) {
                                        for (int j = 0; j < join.getJoinItems().size(); j++) {
                                                TJoinItem joinItem = join.getJoinItems().getJoinItem(j);
                                                TExpression expr = joinItem.getOnCondition();
                                                analyzeFilterCondition(null, expr, joinItem.getJoinType(), JoinClauseType.on,
                                                                EffectType.update);
                                        }
                                }
                        }
                }

                if (stmt.getWhereClause() != null && stmt.getWhereClause().getCondition() != null) {
                        analyzeFilterCondition(null, stmt.getWhereClause().getCondition(), null, JoinClauseType.where,
                                        EffectType.update);
                }

                if (stmt.getOutputClause() != null) {
                        TOutputClause outputClause = stmt.getOutputClause();
                        if (outputClause.getSelectItemList() != null) {
                                ResultSet resultSet = modelFactory.createResultSet(outputClause, false);
                                for (int j = 0; j < outputClause.getSelectItemList().size(); j++) {
                                        TResultColumn sourceColumn = outputClause.getSelectItemList().getResultColumn(j);
                                        ResultColumn sourceColumnModel = modelFactory.createResultColumn(resultSet, sourceColumn);
                                        analyzeResultColumn(sourceColumn, EffectType.select);

                                        if (outputClause.getIntoTable() != null) {
                                                Table intoTableModel = modelFactory.createTableByName(outputClause.getIntoTable());
                                                intoTableModel.addProcess(process);
                                                if (outputClause.getIntoColumnList() != null) {
                                                        TableColumn intoTableColumn = modelFactory.createInsertTableColumn(intoTableModel,
                                                                        outputClause.getIntoColumnList().getObjectName(j));

                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.insert);
                                                        relation.setTarget(new TableColumnRelationshipElement(intoTableColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(sourceColumnModel));
                                                } else if (sourceColumn.getAliasClause() != null
                                                                || sourceColumn.getExpr().getObjectOperand() != null) {
                                                        TObjectName tableColumnObject = null;
                                                        if (sourceColumn.getAliasClause() != null) {
                                                                tableColumnObject = sourceColumn.getAliasClause().getAliasName();
                                                        } else {
                                                                tableColumnObject = sourceColumn.getExpr().getObjectOperand();
                                                        }

                                                        TableColumn intoTableColumn = modelFactory.createInsertTableColumn(intoTableModel,
                                                                        tableColumnObject);
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.insert);
                                                        relation.setTarget(new TableColumnRelationshipElement(intoTableColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(sourceColumnModel));
                                                }
                                        }
                                }
                        }
                }
        }

        /**
         * Analyzes SQL Server XML modify() function to extract data lineage from sql:column() references
         * in XQuery expressions.
         *
         * Example SQL:
         * SET [Demographics].modify('... sql:column("deleted.LineTotal") ...')
         *
         * This extracts:
         * - Target column: Demographics (from the XML column being modified)
         * - Source column: deleted.LineTotal (from sql:column() reference in XQuery)
         */
        private void analyzeXmlModifyFunction(TUpdateSqlStatement stmt, Table tableModel, Process process, TFunctionCall funcCall) {
                TObjectName funcName = funcCall.getFunctionName();
                if (funcName == null || funcName.getPartToken() == null) {
                        return;
                }

                // Get the XML column being modified (e.g., [Demographics] from "[Demographics].modify")
                String xmlColumnName = funcName.getPartToken().astext;

                // Get the XQuery argument
                if (funcCall.getArgs() == null || funcCall.getArgs().size() == 0) {
                        return;
                }

                String xqueryString = funcCall.getArgs().getExpression(0).toString();

                // Extract sql:column() references from the XQuery string
                List<String> sqlColumnRefs = extractSqlColumnReferences(xqueryString);
                if (sqlColumnRefs.isEmpty()) {
                        return;
                }

                // Extract XPath target from XQuery (e.g., /IndividualSurvey/TotalPurchaseYTD)
                String xpathTarget = extractXPathTarget(xqueryString);

                // Build full target column name including XML path
                String fullTargetColumnName = xmlColumnName;
                if (xpathTarget != null && !xpathTarget.isEmpty()) {
                        fullTargetColumnName = xmlColumnName + "." + xpathTarget;
                }

                // Create the target table column for the XML column being modified
                TableColumn targetTableColumn = modelFactory.createInsertTableColumn(tableModel, fullTargetColumnName);

                // Create source-to-target relationships for each sql:column reference
                for (String sqlColRef : sqlColumnRefs) {
                        // Parse the column reference (e.g., "deleted.LineTotal" -> table="deleted", column="LineTotal")
                        String[] parts = sqlColRef.split("\\.", 2);
                        String sourceTableName = parts.length > 1 ? parts[0] : null;
                        String sourceColumnName = parts.length > 1 ? parts[1] : parts[0];

                        // Find the source table in the statement's tables
                        TTable sourceTable = null;
                        if (sourceTableName != null && stmt.tables != null) {
                                for (int j = 0; j < stmt.tables.size(); j++) {
                                        TTable t = stmt.tables.getTable(j);
                                        String tableName = t.getTableName().toString();
                                        String alias = t.getAliasName();
                                        if (SQLUtil.compareIdentifier(option.getVendor(), ESQLDataObjectType.dotTable, tableName, sourceTableName) ||
                                                (alias != null && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotTable, alias, sourceTableName))) {
                                                sourceTable = t;
                                                break;
                                        }
                                }
                        }

                        if (sourceTable != null && targetTableColumn != null) {
                                // Create a table model for the source if needed
                                Table sourceTableModel = modelFactory.createTable(sourceTable);
                                TableColumn sourceColumn = modelFactory.createInsertTableColumn(sourceTableModel, sourceColumnName);

                                if (sourceColumn != null) {
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(EffectType.update);
                                        relation.setTarget(new TableColumnRelationshipElement(targetTableColumn));
                                        relation.addSource(new TableColumnRelationshipElement(sourceColumn));
                                        relation.setProcess(process);
                                        relation.setFunction("modify");
                                }
                        }
                }
        }

        /**
         * Extracts sql:column() references from an XQuery string.
         * Example: 'sql:column("deleted.LineTotal")' -> ["deleted.LineTotal"]
         */
        private List<String> extractSqlColumnReferences(String xquery) {
                List<String> refs = new ArrayList<>();
                if (xquery == null) {
                        return refs;
                }

                int startIdx = 0;
                while ((startIdx = xquery.indexOf("sql:column(", startIdx)) >= 0) {
                        int parenStart = startIdx + "sql:column(".length();
                        int parenEnd = xquery.indexOf(")", parenStart);
                        if (parenEnd < 0) {
                                break;
                        }

                        String arg = xquery.substring(parenStart, parenEnd).trim();
                        // Remove quotes (single or double)
                        if ((arg.startsWith("\"") && arg.endsWith("\"")) ||
                                (arg.startsWith("'") && arg.endsWith("'"))) {
                                arg = arg.substring(1, arg.length() - 1);
                        }

                        if (!arg.isEmpty()) {
                                refs.add(arg);
                        }

                        startIdx = parenEnd + 1;
                }

                return refs;
        }

        /**
         * Extracts the XPath target from an XQuery modify expression.
         * Example: 'replace value of (/IndividualSurvey/TotalPurchaseYTD)[1]' -> "IndividualSurvey.TotalPurchaseYTD"
         */
        private String extractXPathTarget(String xquery) {
                if (xquery == null) {
                        return null;
                }

                // Look for patterns like "(/path/to/element)" or "(/path/to/element)[1]"
                int replaceIdx = xquery.indexOf("replace value of");
                if (replaceIdx < 0) {
                        return null;
                }

                int parenStart = xquery.indexOf("(/", replaceIdx);
                if (parenStart < 0) {
                        return null;
                }

                int parenEnd = xquery.indexOf(")", parenStart);
                if (parenEnd < 0) {
                        return null;
                }

                String xpath = xquery.substring(parenStart + 1, parenEnd);
                // Remove any predicates like [1]
                int bracketIdx = xpath.indexOf("[");
                if (bracketIdx > 0) {
                        xpath = xpath.substring(0, bracketIdx);
                }

                // Convert XPath to dot notation (e.g., /IndividualSurvey/TotalPurchaseYTD -> IndividualSurvey.TotalPurchaseYTD)
                if (xpath.startsWith("/")) {
                        xpath = xpath.substring(1);
                }
                xpath = xpath.replace("/", ".");

                return xpath;
        }

        private void analyzeConstantDataFlowRelation(Object modelObject, List<TParseTreeNode> constants,
                        EffectType effectType, List<TParseTreeNode> functions) {
                analyzeConstantDataFlowRelation(modelObject, constants, effectType, functions, null);
        }

        private void analyzeConstantDataFlowRelation(Object modelObject, List<TParseTreeNode> constants,
                        EffectType effectType, List<TParseTreeNode> functions, Process process) {
                if (constants == null || constants.size() == 0)
                        return;

                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(effectType);
                relation.setProcess(process);

                if (functions != null && !functions.isEmpty()) {
                        relation.setFunction(getFunctionName(functions.get(0)));
                }

                if (modelObject instanceof ResultColumn) {
                        relation.setTarget(new ResultColumnRelationshipElement((ResultColumn) modelObject));

                } else if (modelObject instanceof TableColumn) {
                        relation.setTarget(new TableColumnRelationshipElement((TableColumn) modelObject));

                } else {
                        throw new UnsupportedOperationException();
                }

                if (option.isShowConstantTable()) {
                        Table constantTable = null;
                        if(modelObject instanceof FunctionResultColumn && ((FunctionResultColumn)modelObject).getFunction() instanceof TFunctionCall) {
                                TFunctionCall function = (TFunctionCall)((FunctionResultColumn)modelObject).getFunction();
                                if(function.getFunctionType() == EFunctionType.struct_t) {
                                        constantTable = modelFactory.createConstantsTable(String.valueOf(function.toString().hashCode()));
                                }
                        }
                        if(constantTable == null) {
                                constantTable = modelFactory.createConstantsTable(stmtStack.peek());
                        }
                        for (int i = 0; i < constants.size(); i++) {
                                TParseTreeNode constant = constants.get(i);
                                if (constant instanceof TConstant) {
                                        TableColumn constantColumn = modelFactory.createTableColumn(constantTable, (TConstant) constant);
                                        relation.addSource(new ConstantRelationshipElement(constantColumn));
                                } else if (constant instanceof TObjectName) {
                                        TableColumn constantColumn = modelFactory.createTableColumn(constantTable, (TObjectName) constant,
                                                        false);
                                        if(constantColumn == null) {
                                                continue;
                                        }
                                        relation.addSource(new ConstantRelationshipElement(constantColumn));
                                }
                        }
                }

        }

        private String getFunctionName(TParseTreeNode parseTreeNode) {
                if (parseTreeNode instanceof TFunctionCall) {
                        return ((TFunctionCall) parseTreeNode).getFunctionName().toString();
                }
                if (parseTreeNode instanceof TCaseExpression) {
                        return "case-when";
                }
                return null;
        }

        private void analyzeCreateViewStmt(TCustomSqlStatement stmt, TSelectSqlStatement subquery,
                        TViewAliasClause viewAlias, TObjectName viewName) {

                if (subquery != null) {
                        TTableList tables = subquery.getTables();
                        if (tables != null) {
                                for (int i = 0; i < tables.size(); i++) {
                                        TTable table = tables.getTable(i);
                                        TCustomSqlStatement createView = viewDDLMap
                                                        .get(DlineageUtil.getTableIdentityKey(table.getTableName().toString()));
                                        if (createView != null) {
                                                analyzeCustomSqlStmt(createView);
                                        }
                                }
                        }
                        analyzeSelectStmt(subquery);
                }

        
                if (viewAlias != null && viewAlias.getViewAliasItemList() != null) {
                        TViewAliasItemList viewItems = viewAlias.getViewAliasItemList();
                        Table viewModel = modelFactory.createView(stmt, viewName, true);
                        viewModel.setFromDDL(true);
                        viewModel.setDetermined(true);
                        Process process = modelFactory.createProcess(stmt);
                        viewModel.addProcess(process);
                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(subquery);
                        if (resultSetModel != null) {
                                int resultSetSize = resultSetModel.getColumns().size();
                                int viewItemSize = viewItems.size();
                                int j = 0;
                                int viewColumnSize = viewItemSize;
                                if (resultSetModel.isDetermined() && resultSetSize > viewColumnSize) {
                                        viewColumnSize = resultSetSize;
                                }
                                // two or more stars of unknown width leave the boundary between them unknown: each view column reads every
                                // select item that can stand at its position, as an INSERT column list does (Mantis 4915); a set
                                // operation with a star of unknown width, from each of its selects (Mantis 4914)
                                List<TObjectName> aliases = viewColumnAliases(viewItems);
                                List<SelectPositions> setSelects = subquery != null && subquery.isCombinedQuery()
                                                ? setOperationPositions(subquery, aliases.size(), shorterList(aliases)) : null;
                                boolean byCandidates = setSelects != null || starColumnCount(resultSetModel.getColumns()) > 1;
                                if (byCandidates) {
                                        mapViewColumnsByCandidates(viewModel, aliases, setSelects != null ? setSelects
                                                        : Collections.singletonList(
                                                                        selectPositions(resultSetModel.getColumns(), aliases.size(), shorterList(aliases))),
                                                        EffectType.create_view, process);
                                }
                                for (int i = 0; !byCandidates && i < viewColumnSize && j < resultSetSize; i++) {
                                        ResultColumn resultColumn = resultSetModel.getColumns().get(j);                                 
                                        if (i < viewItemSize) {
                                                TObjectName alias = viewItems.getViewAliasItem(i).getAlias();
                                                List<ResultColumn> structItem = null;

                                                if (!resultSetModel.getColumns().get(j).isStarColumn()) {
                                                        // a select item that builds a STRUCT is one position, all of its fields (rule R8)
                                                        int width = selectItemWidth(resultSetModel.getColumns(), j);
                                                        if (width > 1 || structFieldPaths.containsKey(resultColumn)) {
                                                                structItem = new ArrayList<ResultColumn>(resultSetModel.getColumns().subList(j, j + width));
                                                        }
                                                        j += width;
                                                } else {
                                                        if (selectItemsFrom(resultSetModel.getColumns(), j, resultSetSize) == viewItems.size() - i) {
                                                                j++;
                                                        }
                                                }

                                                if (alias != null && structItem != null) {
                                                        TableColumn viewColumn = modelFactory.createViewColumn(viewModel, alias, i, true);
                                                        appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        feedFromStructItem(viewColumn, structItem, alias, EffectType.create_view, process, true);
                                                } else if (alias != null) {
                                                        TableColumn viewColumn = modelFactory.createViewColumn(viewModel, alias, i, true);
                                                        appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        if (resultColumn != null) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.create_view);
                                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                relation.addSource(positionSource(resultColumn));
                                                                relation.setProcess(process);
                                                        }
                                                } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                        TableColumn viewColumn = modelFactory.createViewColumn(viewModel,
                                                                        (TObjectName) resultColumn.getColumnObject(), i, true);
                                                        appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        if (resultColumn != null) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.create_view);
                                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.setProcess(process);
                                                        }
                                                } else if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                                        TableColumn viewColumn = modelFactory.createViewColumn(viewModel,
                                                                        ((TResultColumn) resultColumn.getColumnObject()).getFieldAttr(), i, true);
                                                        appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        ResultColumn column = (ResultColumn) modelManager.getModel(resultColumn.getColumnObject());
                                                        if (column != null && column.hasStarLinkColumn()) {
                                                                viewColumn.shareStarLinksFrom(column);
                                                        }
                                                        if (resultColumn != null) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.create_view);
                                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.setProcess(process);
                                                        }
                                                }
                                        }
                                        else if(resultSetModel.isDetermined()){
                                                TObjectName viewColumnName = new TObjectName();
                                                viewColumnName.setString(resultColumn.getName());
                                                TableColumn viewColumn = modelFactory.createViewColumn(viewModel, viewColumnName, viewModel.getColumns().size(), true);
                                                viewColumn.inheritIdentifier(resultColumn);
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.create_view);
                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                relation.setProcess(process);
                                                j++;
                                        }
                                }
                                if (resultSetModel != null && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.setEffectType(EffectType.create_view);
                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        resultSetModel.getRelationRows()));
                                        impactRelation.setTarget(
                                                        new RelationRowsRelationshipElement<TableRelationRows>(viewModel.getRelationRows()));
                                }
                        }

                        if (subquery.getResultColumnList() == null && subquery.getValueClause() != null
                                        && subquery.getValueClause().getValueRows().size() == viewItems.size()) {
                                for (int i = 0; i < viewItems.size(); i++) {
                                        TObjectName alias = viewItems.getViewAliasItem(i).getAlias();

                                        if (alias != null) {
                                                TableColumn viewColumn = modelFactory.createViewColumn(viewModel, alias, i, true);
                                                appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                TExpression expression = subquery.getValueClause().getValueRows().getValueRowItem(i).getExpr();

                                                columnsInExpr visitor = new columnsInExpr();
                                                expression.inOrderTraverse(visitor);
                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                List<TParseTreeNode> functions = visitor.getFunctions();

                                                if (functions != null && !functions.isEmpty()) {
                                                        analyzeFunctionDataFlowRelation(viewColumn, functions, EffectType.select);

                                                }

                                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                                if (subquerys != null && !subquerys.isEmpty()) {
                                                        analyzeSubqueryDataFlowRelation(viewColumn, subquerys, EffectType.select);
                                                }

                                                analyzeDataFlowRelation(viewColumn, objectNames, EffectType.select, functions);
                                                List<TParseTreeNode> constants = visitor.getConstants();
                                                analyzeConstantDataFlowRelation(viewColumn, constants, EffectType.select, functions);
                                        }
                                }
                        }

                } else {
                        if (viewName == null) {
                                ErrorInfo errorInfo = new ErrorInfo();
                                errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                                errorInfo.setErrorMessage("Can't get view name. CreateView is " + stmt.toString());
                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(stmt.getStartToken().lineNo,
                                                stmt.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(stmt.getEndToken().lineNo,
                                                stmt.getEndToken().columnNo + stmt.getEndToken().getAstext().length(),
                                                ModelBindingManager.getGlobalHash()));
                                errorInfo.fillInfo(this);
                                errorInfos.add(errorInfo);
                                return;
                        }
                        Table viewModel = modelFactory.createView(stmt, viewName);
                        Process process = modelFactory.createProcess(stmt);
                        viewModel.addProcess(process);
                        if (subquery != null && !subquery.isCombinedQuery()) {
                                SelectResultSet resultSetModel = (SelectResultSet) modelManager
                                                .getModel(subquery.getResultColumnList());

                                boolean determined = false;
                                if (!containStarColumn(resultSetModel)) {
                                        viewModel.setCreateTable(true);
                                        determined = true;
                                        viewModel.setFromDDL(true);
                                }
                                for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                        ResultColumn resultColumn = resultSetModel.getColumns().get(i);
                                        if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                                TResultColumn columnObject = ((TResultColumn) resultColumn.getColumnObject());

                                                TAliasClause alias = ((TResultColumn) resultColumn.getColumnObject()).getAliasClause();
                                                if (alias != null && alias.getAliasName() != null) {
                                                        TableColumn viewColumn = modelFactory.createViewColumn(viewModel, alias.getAliasName(), i,
                                                                        determined);
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_view);
                                                        relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.setProcess(process);
                                                        if (determined) {
                                                                appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        }
                                                } else if (columnObject.getFieldAttr() != null) {
                                                        TObjectName viewColumnObject = columnObject.getFieldAttr();
                                                        TableColumn viewColumn;
                                                        Object model = modelManager.getModel(resultColumn.getColumnObject());
                                                        // customer.* expanded to the fields of customer (STRUCT tree) is a wildcard item too
                                                        if (DlineageUtil.isWildcard(viewColumnObject) || (nestedProfile().buildsDeclaredTree()
                                                                        && viewColumnObject.getStructStarPath() != null)) {
                                                                if (model instanceof LinkedHashMap) {
                                                                        String columnName = getColumnNameOnly(resultColumn.getName());
                                                                        LinkedHashMap<String, ResultColumn> resultColumns = (LinkedHashMap<String, ResultColumn>) model;
                                                                        if (resultColumn.isStarColumn()) {
                                                                                for (String key : resultColumns.keySet()) {
                                                                                        ResultColumn column = resultColumns.get(key);
                                                                                        viewColumn = itemColumnTarget(viewModel, column);
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.create_view);
                                                                                        relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(column));
                                                                                        relation.setProcess(process);
                                                                                }
                                                                                continue;
                                                                        } else if (resultColumns.containsKey(columnName)) {
                                                                                ResultColumn column = resultColumns.get(columnName);
                                                                                viewColumn = modelFactory.createInsertTableColumn(viewModel, column);
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.create_view);
                                                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(column));
                                                                                relation.setProcess(process);
                                                                                continue;
                                                                        }
                                                                }
                                                        }
                                                        
                                                        if (!SQLUtil.isEmpty(viewColumnObject.getColumnNameOnly())
                                                                        && viewColumnObject.getPropertyToken() != null) {
                                                                TObjectName object = new TObjectName();
                                                                // object.setString(viewColumnObject.getPropertyToken().astext);
                                                                // the view column is named after the last field: payload.address.city gives city
                                                                TSourceToken leaf = DlineageUtil.propertyLeafToken(viewColumnObject);
                                                                object.setPartToken(leaf);
                                                                object.setStartToken(leaf);
                                                                object.setEndToken(leaf);
                                                                if (!structStarOfUnknownFields(viewColumnObject, resultColumn)) {
                                                                        viewColumn = modelFactory.createViewColumn(viewModel, object, i, determined);
                                                                } else {
                                                                        // STRUCT tree: customer.* without declared fields is one column standing for every
                                                                        // field of customer, as its result column is; not a wildcard over a relation, whose
                                                                        // expansion published the struct itself as a view column (Mantis 4827)
                                                                        viewColumn = modelFactory.createStructStarViewColumn(viewModel, object, i, determined);
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.create_view);
                                                                        relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.setProcess(process);
                                                                        continue;
                                                                }
                                                        } else {
                                                                viewColumn = modelFactory.createViewColumn(viewModel, columnObject.getFieldAttr(),
                                                                                i, determined);
                                                        }
                                                        
                                                        if(determined) {
                                                                appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        }
                                                        
                                                        if (model instanceof ResultColumn) {
                                                                ResultColumn column = (ResultColumn) modelManager
                                                                                .getModel(resultColumn.getColumnObject());
                                                                if (column != null && column.hasStarLinkColumn()) {
                                                                        viewColumn.shareStarLinksFrom(column);
                                                                }
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.create_view);
                                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                if (sqlenv == null) {
                                                                        if (resultColumn.isShowStar()) {
                                                                                relation.setShowStarRelation(true);
                                                                                viewColumn.setShowStar(true);
                                                                                resultColumn.setShowStar(true);
                                                                                setSourceShowStar(resultColumn);
                                                                        }
                                                                }
                                                                if (viewColumn.isStarColumn() && resultColumn.isStarColumn()) {
                                                                        viewModel.setStarStmt("create_view");
                                                                }
                                                                relation.setProcess(process);
                                                        }
                                                } else if (resultColumn.getAlias() != null && columnObject.getExpr()
                                                                .getExpressionType() == EExpressionType.sqlserver_proprietary_column_alias_t) {
                                                        TableColumn viewColumn = modelFactory.createViewColumn(viewModel,
                                                                        columnObject.getExpr().getLeftOperand().getObjectOperand(), i, determined);
                                                        if(determined) {
                                                                appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        }
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_view);
                                                        relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.setProcess(process);
                                                } else {
                                                        TGSqlParser parser = columnObject.getGsqlparser();
                                                        TObjectName viewColumnName = parser
                                                                        .parseObjectName(generateQuotedName(parser, columnObject.toString()));
                                                        if (viewColumnName == null) {
                                                                ErrorInfo errorInfo = new ErrorInfo();
                                                                errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                                                                errorInfo.setErrorMessage(
                                                                                "Can't parse view column. Column is " + columnObject.toString());
                                                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(
                                                                                columnObject.getStartToken().lineNo, columnObject.getStartToken().columnNo,
                                                                                ModelBindingManager.getGlobalHash()));
                                                                errorInfo
                                                                                .setEndPosition(new Pair3<Long, Long, String>(columnObject.getEndToken().lineNo,
                                                                                                columnObject.getEndToken().columnNo
                                                                                                                + columnObject.getEndToken().getAstext().length(),
                                                                                                ModelBindingManager.getGlobalHash()));
                                                                errorInfo.fillInfo(this);
                                                                errorInfos.add(errorInfo);
                                                        } else {
                                                                TableColumn viewColumn = modelFactory.createViewColumn(viewModel, viewColumnName, i,
                                                                                determined);
                                                                if(determined) {
                                                                        appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                                }
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.create_view);
                                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.setProcess(process);
                                                        }
                                                }
                                        } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                TObjectName viewColumnName = (TObjectName) resultColumn.getColumnObject();
                                                StructFieldPath rowField = structFieldPaths.get(resultColumn);
                                                if (rowField != null && rowField.alias != null) {
                                                        // STRUCT tree: a field of a ROW the query builds, contact.city of CAST(ROW(..) AS ROW(city ..))
                                                        // AS contact, is the field node contact.city below the view's declared column contact, so a
                                                        // later read of v.contact.city binds to it (Mantis 4834)
                                                        TObjectName alias = rowField.alias;
                                                        boolean first = modelManager.getViewModel(new Pair<Table, TObjectName>(viewModel, alias)) == null;
                                                        TableColumn declared = modelFactory.createViewColumn(viewModel, alias, i, determined);
                                                        TableColumn node = declared == null ? null
                                                                        : modelFactory.createFieldPath(declared, rowField.segments(), alias);
                                                        if (node != null) {
                                                                if (determined && first) {
                                                                        appendTableColumnToSQLEnv(viewModel, declared);
                                                                }
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.create_view);
                                                                relation.setTarget(new ViewColumnRelationshipElement(node));
                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.setProcess(process);
                                                                continue;
                                                        }
                                                }
                                                TableColumn viewColumn = modelFactory.createViewColumn(viewModel, viewColumnName, i, determined);
                                                if(determined) {
                                                        appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                }
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.create_view);
                                                relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                relation.setProcess(process);
                                        }
                                }
                                if (!resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.setEffectType(EffectType.create_view);
                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        resultSetModel.getRelationRows()));
                                        impactRelation.setTarget(
                                                        new RelationRowsRelationshipElement<TableRelationRows>(viewModel.getRelationRows()));
                                }
                        } else if (subquery != null && subquery.isCombinedQuery()) {
                                SelectSetResultSet resultSetModel = (SelectSetResultSet) modelManager.getModel(subquery);

                                boolean determined = false;
                                if (!containStarColumn(resultSetModel)) {
                                        viewModel.setCreateTable(true);
                                        viewModel.setFromDDL(true);
                                        determined = true;
                                }

                                for (int i = 0; i < resultSetModel.getColumns().size(); i++) {
                                        ResultColumn resultColumn = resultSetModel.getColumns().get(i);

                                        if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                                TResultColumn columnObject = ((TResultColumn) resultColumn.getColumnObject());

                                                TAliasClause alias = columnObject.getAliasClause();
                                                if (alias != null && alias.getAliasName() != null) {
                                                        TableColumn viewColumn = modelFactory.createViewColumn(viewModel, alias.getAliasName(), i,
                                                                        determined);
                                                        if(determined) {
                                                                appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        }
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_view);
                                                        relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.setProcess(process);
                                                } else if (columnObject.getFieldAttr() != null) {
                                                        TableColumn viewColumn = modelFactory.createViewColumn(viewModel,
                                                                        columnObject.getFieldAttr(), i, determined);
                                                        if(determined) {
                                                                appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        }
                                                        ResultColumn column = (ResultColumn) modelManager.getModel(resultColumn.getColumnObject());
                                                        if (column != null && column.hasStarLinkColumn()) {
                                                                viewColumn.shareStarLinksFrom(column);
                                                        }
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_view);
                                                        relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.setProcess(process);
                                                } else if (resultColumn.getAlias() != null && columnObject.getExpr()
                                                                .getExpressionType() == EExpressionType.sqlserver_proprietary_column_alias_t) {
                                                        TableColumn viewColumn = modelFactory.createViewColumn(viewModel,
                                                                        columnObject.getExpr().getLeftOperand().getObjectOperand(), i, determined);
                                                        if(determined) {
                                                                appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        }
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_view);
                                                        relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.setProcess(process);
                                                } else {
                                                        TGSqlParser parser = columnObject.getGsqlparser();
                                                        TObjectName viewColumnName = parser
                                                                        .parseObjectName(generateQuotedName(parser, columnObject.toString()));
                                                        TableColumn viewColumn = modelFactory.createViewColumn(viewModel, viewColumnName, i,
                                                                        determined);
                                                        if(determined) {
                                                                appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        }
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_view);
                                                        relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.setProcess(process);
                                                }
                                        } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                TableColumn viewColumn = modelFactory.createViewColumn(viewModel,
                                                                (TObjectName) resultColumn.getColumnObject(), i, determined);
                                                if(viewColumn!=null) {
                                                        if(determined) {
                                                                appendTableColumnToSQLEnv(viewModel, viewColumn);
                                                        }
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.create_view);
                                                        relation.setTarget(new ViewColumnRelationshipElement(viewColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.setProcess(process);
                                                }
                                        }
                                }
                                if (!resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.setEffectType(EffectType.create_view);
                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        resultSetModel.getRelationRows()));
                                        impactRelation.setTarget(
                                                        new RelationRowsRelationshipElement<TableRelationRows>(viewModel.getRelationRows()));
                                }
                        }
                }
        }

        private void setSourceShowStar(Object resultColumn) {
                for (Relationship relation : modelManager.getRelations()) {
                        Collection<RelationshipElement<?>> sources = (Collection<RelationshipElement<?>>)relation.getSources();
                        if (relation.getTarget().getElement() == resultColumn && sources != null) {

                                ((AbstractRelationship) relation).setShowStarRelation(true);
                                for (RelationshipElement<?> source : sources) {
                                        Object column = source.getElement();
                                        if (column instanceof TableColumn) {
                                                if (((TableColumn) column).isShowStar())
                                                        continue;
                                                ((TableColumn) column).setShowStar(true);
                                        }
                                        if (column instanceof ResultColumn) {
                                                if (((ResultColumn) column).isShowStar())
                                                        continue;
                                                ((ResultColumn) column).setShowStar(true);
                                        }
                                        setSourceShowStar(column);
                                }
                        }
                }
        }

        private String generateQuotedName(TGSqlParser parser, String name) {
                return "\"" + name + "\"";
        }

        private void appendRelations(dataflow dataflow) {
                Relationship[] relations = modelManager.getRelations();

                appendRelation(dataflow, relations, DataFlowRelationship.class);
                appendRelation(dataflow, relations, IndirectImpactRelationship.class);
                appendRecordSetRelation(dataflow, relations);
                appendCallRelation(dataflow, relations);
                appendRelation(dataflow, relations, ImpactRelationship.class);
                appendRelation(dataflow, relations, JoinRelationship.class);
                appendRelation(dataflow, relations, ERRelationship.class);
                appendRelation(dataflow, relations, CrudRelationship.class);
                reconcileCitedColumns(dataflow);
        }

        /**
         * Invariant enforcement (codex-696 F5): a relationship must never cite a
         * column its parent element does not declare. Star/variant columns of
         * record variables can be cited raw (a whole-record source in a filter,
         * an unexpanded fill) while the model writer only emitted their
         * star-linked expansions — declare exactly the cited leftovers, nothing
         * more.
         */
        private void reconcileCitedColumns(dataflow dataflow) {
                // VARIABLES only: the undeclared-endpoint family is a record variable's
                // star/variant column cited raw. Declaring cited leftovers on tables or
                // resultsets changes what downstream consumers (JSON conversion,
                // normalized comparison) derive from the model — churn far beyond the
                // invariant this pass exists to keep.
                Map<String, table> parents = new HashMap<String, table>();
                if (dataflow.getVariables() != null) {
                        for (table t : dataflow.getVariables()) {
                                if (t.getId() != null) {
                                        parents.put(t.getId(), t);
                                }
                        }
                }
                if (dataflow.getRelationships() == null) {
                        return;
                }
                Set<String> declared = new HashSet<String>();
                for (table t : parents.values()) {
                        if (t.getColumns() == null) {
                                continue;
                        }
                        for (column c : t.getColumns()) {
                                declared.add(t.getId() + ":" + c.getId());
                        }
                }
                for (relationship relation : dataflow.getRelationships()) {
                        if (relation.getSources() != null) {
                                for (sourceColumn source : relation.getSources()) {
                                        declareCitedColumn(parents, declared, source.getParent_id(), source.getId(),
                                                        source.getColumn(), source.getCoordinate());
                                }
                        }
                        targetColumn target = relation.getTarget();
                        if (target != null) {
                                declareCitedColumn(parents, declared, target.getParent_id(), target.getId(),
                                                target.getColumn(), target.getCoordinate());
                        }
                }
        }

        private void declareCitedColumn(Map<String, table> parents, Set<String> declared,
                        String parentId, String columnId, String columnName, String coordinate) {
                if (parentId == null || columnId == null || columnName == null) {
                        return;
                }
                String key = parentId + ":" + columnId;
                if (declared.contains(key)) {
                        return;
                }
                table parent = parents.get(parentId);
                if (parent == null) {
                        return;
                }
                column columnElement = new column();
                columnElement.setId(columnId);
                columnElement.setName(columnName);
                if (coordinate != null) {
                        columnElement.setCoordinate(coordinate);
                }
                parent.getColumns().add(columnElement);
                declared.add(key);
        }
        
        
        private relationship cloneRelationshipWithSingleSource(relationship orig, sourceColumn src) {
                relationship rel = new relationship();
                rel.setType(orig.getType());
                rel.setEffectType(orig.getEffectType());
                rel.setId(orig.getId() + "_" + src.getColumn());
                rel.setSqlHash(orig.getSqlHash());
                rel.setSqlComment(orig.getSqlComment());
                rel.setProcessId(orig.getProcessId());
                rel.setProcessType(orig.getProcessType());
                rel.setFunction(orig.getFunction());
                rel.setProcedureId(orig.getProcedureId());

                targetColumn t = new targetColumn();
                t.setId(orig.getTarget().getId());
                t.setColumn(orig.getTarget().getColumn());
                t.setParent_id(orig.getTarget().getParent_id());
                t.setParent_name(orig.getTarget().getParent_name());
                t.setParent_alias(orig.getTarget().getParent_alias());
                t.setCoordinate(orig.getTarget().getCoordinate());
                rel.setTarget(t);

                sourceColumn s = new sourceColumn();
                s.setId(src.getId());
                s.setColumn(src.getColumn());
                s.setParent_id(src.getParent_id());
                s.setParent_name(src.getParent_name());
                s.setCoordinate(src.getCoordinate());
                rel.addSource(s);
                return rel;
        }

        private Set<Object> appendStarColumns = new HashSet<Object>();
        private void appendRelation(dataflow dataflow, Relationship[] relations, Class<? extends Relationship> clazz) {
                for (int i = 0; i < relations.length; i++) {
                        AbstractRelationship relation = (AbstractRelationship) relations[i];
                        if (relation.getClass() == clazz) {
                                if (relation.getSources() == null || relation.getTarget() == null) {
                                        continue;
                                }
                                Object targetElement = relation.getTarget().getElement();
                                boolean targetIsStar = targetElement instanceof Column && ((Column) targetElement).isStarColumn();
                                TObjectName targetColumnName = null;
                                if(relation.getTarget() instanceof ResultColumnRelationshipElement) {
                                        targetColumnName = ((ResultColumnRelationshipElement) relation.getTarget()).getColumnName();
                                }
                                if (targetElement instanceof ResultColumn) {
                                        ResultColumn targetColumn = (ResultColumn) targetElement;
                                        if (!targetColumn.isPseduo()) 
                                        {
                                                if (targetColumnName == null) 
                                                {
                                                        if (targetColumn.isStarColumn()) {
                                                                updateResultColumnStarLinks(dataflow, relation, -1);
                                                        }

                                                        if (targetColumn.hasStarLinkColumn()) {
                                                                for (int j = 0; j < targetColumn.starLinkCount(); j++) {
                                                                        appendStarRelation(dataflow, relation, j);
                                                                }

                                                                if (!containsStar(relation.getSources())) {
                                                                        continue;
                                                                }
                                                        }
                                                }
                                                else {
                                                        int index = targetColumn.starLinkIndexOf(targetColumnName);
                                                        if (index != -1) {
                                                                int size = targetColumn.starLinkCount();
                                                                if (targetColumn.isStarColumn()) {
                                                                        Object linkKey = targetColumn.starLinkKey(index);
                                                                        if (appendStarColumns.contains(linkKey)) {
                                                                                updateResultColumnStarLinks(dataflow, relation, index);
                                                                        }
                                                                        else {
                                                                                updateResultColumnStarLinks(dataflow, relation, -1);
                                                                                appendStarColumns.add(linkKey);
                                                                        }
                                                                }
                                                                appendStarRelation(dataflow, relation, index);
                                                                for(int j= size; j < targetColumn.starLinkCount(); j++) {
                                                                        appendStarRelation(dataflow, relation, j);
                                                                }
                                                                if (!containsStar(relation.getSources())) {
                                                                        continue;
                                                                }
                                                        }
                                                }
                                        }
                                } else if (targetElement instanceof TableColumn) {
                                        TableColumn targetColumn = (TableColumn) targetElement;
                                        if (!targetColumn.isPseduo()) {
                                                if (targetColumn.isStarColumn()) {
                                                        updateTableColumnStarLinks(dataflow, relation);
                                                }

                                                // Star expansion selected by HOLDER type (#695): a
                                                // VARIABLE's variant column is serialized as its
                                                // star-linked fields (appendVariableModel), so a
                                                // relation targeting it must expand onto those fields
                                                // or it cites a column the model never declares. A
                                                // physical table's variant column keeps the historical
                                                // refusal (appendTableModel refuses variant).
                                                boolean variantOfVariable = targetColumn.isVariant()
                                                                && targetColumn.getTable() instanceof Variable;
                                                if (targetColumn.hasStarLinkColumn()
                                                                && ((!targetColumn.isVariant() && targetColumn.isExpandStar())
                                                                                || variantOfVariable)) {
                                                        for (int j = 0; j < targetColumn.starLinkCount(); j++) {
                                                                appendStarRelation(dataflow, relation, j);
                                                        }
                                                        if (!containsStar(relation.getSources())) {
                                                                continue;
                                                        }
                                                }
                                        }
                                }

                                relationship relationElement = new relationship();
                                relationElement.setType(relation.getRelationshipType().name());
                                if (relation.getEffectType() != null) {
                                        relationElement.setEffectType(relation.getEffectType().name());
                                }
                                if (relation.getFunction() != null) {
                                        relationElement.setFunction(relation.getFunction());
                                }
                                relationElement.setSqlHash(relation.getSqlHash());
                                relationElement.setSqlComment(relation.getSqlComment());

                                if (relation.getProcedureId() != null) {
                                        relationElement.setProcedureId(String.valueOf(relation.getProcedureId()));
                                }
                                relationElement.setId(String.valueOf(relation.getId()));
                                if (relation.getProcess() != null) {
                                        relationElement.setProcessId(String.valueOf(relation.getProcess().getId()));
                                        if (relation.getProcess().getGspObject() != null) {
                                                relationElement.setProcessType(relation.getProcess().getGspObject().sqlstatementtype.name());
                                        }
                                }

                                if (relation.getPartition() != null) {
                                        relationElement.setPartition(relation.getPartition());
                                }
                                relationElement.setSqlHash(relation.getSqlHash());
                                relationElement.setSqlComment(relation.getSqlComment());
                                
                                if (relation.getProcedureId() != null) {
                                        relationElement.setProcedureId(String.valueOf(relation.getProcedureId()));
                                }
                                
                                if (relation instanceof JoinRelationship) {
                                        relationElement.setCondition(((JoinRelationship) relation).getJoinCondition());
                                        relationElement.setJoinType(((JoinRelationship) relation).getJoinType().name());
                                        relationElement.setClause(((JoinRelationship) relation).getJoinClauseType().name());
                                }

                                if(relation instanceof ImpactRelationship){
                                        ImpactRelationship impactRelationship = (ImpactRelationship)relation;
                                        if(impactRelationship.getJoinClauseType()!=null){
                                                relationElement.setClause(impactRelationship.getJoinClauseType().name());
                                        }
                                }

                                String targetName = null;
                                Object columnObject = null;
                                List<TObjectName> targetObjectNames = null;

                                if (targetElement instanceof ResultSetRelationRows) {
                                        ResultSetRelationRows targetColumn = (ResultSetRelationRows) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setId(String.valueOf(targetColumn.getId()));
                                        target.setColumn(targetColumn.getName());
                                        target.setParent_id(String.valueOf(targetColumn.getHolder().getId()));
                                        target.setParent_name(getResultSetName(targetColumn.getHolder()));
                                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                                + convertCoordinate(targetColumn.getEndPosition()));
                                        }
                                        if (relation instanceof RecordSetRelationship) {
                                                target.setFunction(((RecordSetRelationship) relation).getAggregateFunction());
                                        }
                                        target.setSource("system");
                                        targetName = targetColumn.getName();
                                        relationElement.setTarget(target);
                                } else if (targetElement instanceof TableRelationRows) {
                                        TableRelationRows targetColumn = (TableRelationRows) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setId(String.valueOf(targetColumn.getId()));
                                        target.setColumn(targetColumn.getName());
                                        target.setParent_id(String.valueOf(targetColumn.getHolder().getId()));
                                        target.setParent_name(getTableName(targetColumn.getHolder()));
                                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                                + convertCoordinate(targetColumn.getEndPosition()));
                                        }
                                        if (relation instanceof RecordSetRelationship) {
                                                target.setFunction(((RecordSetRelationship) relation).getAggregateFunction());
                                        }
                                        target.setSource("system");
                                        targetName = targetColumn.getName();
                                        relationElement.setTarget(target);
                                } else if (targetElement instanceof ResultColumn) {
                                        ResultColumn targetColumn = (ResultColumn) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setId(String.valueOf(targetColumn.getId()));
                                        target.setColumn(targetColumn.getName());
                                        target.setStruct(targetColumn.isStruct());
                                        target.setParent_id(String.valueOf(targetColumn.getResultSet().getId()));
                                        target.setParent_name(getResultSetName(targetColumn.getResultSet()));
                                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                                + convertCoordinate(targetColumn.getEndPosition()));
                                        }
                                        if (relation instanceof RecordSetRelationship) {
                                                target.setFunction(((RecordSetRelationship) relation).getAggregateFunction());
                                        }
                                        targetName = targetColumn.getName();
                                        if (((ResultColumn) targetColumn).getColumnObject() instanceof TResultColumn) {
                                                columnsInExpr visitor = new columnsInExpr();
                                                ((TResultColumn) ((ResultColumn) targetColumn).getColumnObject()).getExpr()
                                                                .inOrderTraverse(visitor);
                                                targetObjectNames = visitor.getObjectNames();
                                        }

                                        if (targetElement instanceof FunctionResultColumn) {
                                                columnObject = ((FunctionResultColumn) targetElement).getColumnObject();
                                        }
                                        if(targetColumn.isPseduo()) {
                                                target.setSource("system");
                                        }
                                        relationElement.setTarget(target);
                                } else if (targetElement instanceof TableColumn) {
                                        TableColumn targetColumn = (TableColumn) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setId(String.valueOf(targetColumn.getId()));
                                        target.setColumn(targetColumn.getName());
                                        target.setStruct(targetColumn.isStruct());
                                        target.setParent_id(String.valueOf(targetColumn.getTable().getId()));
                                        target.setParent_name(getTableName(targetColumn.getTable()));
                                        if (relation.getTarget() instanceof TableColumnRelationshipElement) {
                                                target.setParent_alias(((TableColumnRelationshipElement) relation.getTarget()).getTableAlias());
                                        }
                                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                                + convertCoordinate(targetColumn.getEndPosition()));
                                        }
                                        if (relation instanceof RecordSetRelationship) {
                                                target.setFunction(((RecordSetRelationship) relation).getAggregateFunction());
                                        }
                                        if(targetColumn.isPseduo()) {
                                                target.setSource("system");
                                        }
                                        targetName = targetColumn.getName();
                                        relationElement.setTarget(target);
                                } else if (targetElement instanceof Argument) {
                                        Argument targetColumn = (Argument) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setId(String.valueOf(targetColumn.getId()));
                                        target.setColumn(targetColumn.getName());
                                        target.setParent_id(String.valueOf(targetColumn.getProcedure().getId()));
                                        target.setParent_name(targetColumn.getProcedure().getName());
                                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                                + convertCoordinate(targetColumn.getEndPosition()));
                                        }
                                        if (relation instanceof RecordSetRelationship) {
                                                target.setFunction(((RecordSetRelationship) relation).getAggregateFunction());
                                        }
                                        targetName = targetColumn.getName();
                                        relationElement.setTarget(target);
                                } else if (targetElement instanceof Table) {
                                        Table table = (Table) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setTarget_id(String.valueOf(table.getId()));
                                        target.setTarget_name(getTableName(table));
                                        if (table.getStartPosition() != null && table.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(table.getStartPosition()) + ","
                                                                + convertCoordinate(table.getEndPosition()));
                                        }
                                        relationElement.setTarget(target);
                                } else {
                                        continue;
                                }

                                Collection<RelationshipElement<?>> sourceElements = relation.getSources();
                                if (sourceElements.size() == 0) {
                                        if(clazz == CrudRelationship.class && option.getAnalyzeMode() == AnalyzeMode.crud) {
                                                dataflow.getRelationships().add(relationElement);
                                        }
                                        continue;
                                }

                                boolean append = false;
                                for (RelationshipElement<?> sourceItem: relation.getSources()) {
                                        Object sourceElement = sourceItem.getElement();
                                        TObjectName sourceColumnName = null;
                                        if (sourceItem instanceof ResultColumnRelationshipElement) {
                                                sourceColumnName = ((ResultColumnRelationshipElement) sourceItem).getColumnName();
                                        }
//                                      if (sourceItem instanceof TableColumnRelationElement
//                                                      && (((TableColumnRelationElement) sourceItem).getColumnIndex() != null)) {
//                                              TableColumnRelationElement tableColumnRelationElement = (TableColumnRelationElement) sourceItem;
//                                              sourceElement = tableColumnRelationElement.getElement().getTable().getColumns()
//                                                              .get(tableColumnRelationElement.getColumnIndex() + 1);
//                                      }
                                        if (sourceElement instanceof ResultColumn) {
                                                ResultColumn sourceColumn = (ResultColumn) sourceElement;
                                                if (sourceColumn.hasStarLinkColumn() && !relation.isShowStarRelation() && !sourceColumn.isPseduo()) {
                                                        List<String> sourceStarColumnNames = sourceColumn.getStarLinkColumnNames();
                                                        sourceColumn source = new sourceColumn();
                                                        if (targetObjectNames != null && !targetObjectNames.isEmpty()) {

                                                                for (int k = 0; k < targetObjectNames.size(); k++) {
                                                                        String targetObjectName = getColumnName(targetObjectNames.get(k));
                                                                        if(sourceColumn.getResultSet()!=null && sourceColumn.getResultSet().getColumns()!=null) {
                                                                                boolean find = false;
                                                                                for(ResultColumn column: sourceColumn.getResultSet().getColumns()) {
                                                                                        if(column.isStarColumn() == DlineageUtil.isStarName(targetObjectNames.get(k))
                                                                                                        && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, column.getName(), rawColumnSpelling(targetObjectNames.get(k)))) {
                                                                                                source = new sourceColumn();
                                                                                                source.setId(String.valueOf(column.getId()));
                                                                                                source.setColumn(targetObjectName);
                                                                                                source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                                                                source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                                                                setSourceCoordinate(source, sourceItem, sourceColumn);
                                                                                                append = true;
                                                                                                relationElement.addSource(source);
                                                                                                find = true;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                                if(find) {
                                                                                        continue;
                                                                                }
                                                                        }
                                                                        int link = sourceColumn.starLinkIndexOf(targetObjectNames.get(k));
                                                                        if (link >= 0) {
                                                                                source = new sourceColumn();
                                                                                source.setId(String.valueOf(sourceColumn.getId()) + "_" + link);
                                                                                source.setColumn(sourceColumn.starLinkName(link));
                                                                                source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                                                source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                                                setSourceCoordinate(source, sourceItem, sourceColumn);
                                                                                append = true;
                                                                                relationElement.addSource(source);
                                                                        } else {
                                                                                source = new sourceColumn();
                                                                                source.setId(String.valueOf(sourceColumn.getId()));
                                                                                source.setColumn(relationElement.getTarget().getColumn());
                                                                                source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                                                source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                                                setSourceCoordinate(source, sourceItem, sourceColumn);
                                                                                append = true;
                                                                                relationElement.addSource(source);
                                                                        }
                                                                }
                                                        } else {
                                                                if (columnObject instanceof TWhenClauseItemList) {
                                                                        TCaseExpression expr = (TCaseExpression)((FunctionResultColumn) targetElement).getResultSet().getGspObject();
                                                                        List<TExpression> directExpressions = new ArrayList<TExpression>();
                                                                        
//                                                                      TExpression inputExpr = expr.getInput_expr();
//                                                                      if (inputExpr != null) {
//                                                                              directExpressions.add(inputExpr);
//                                                                      }
                                                                        TExpression defaultExpr = expr.getElse_expr();
                                                                        if (defaultExpr != null) {
                                                                                directExpressions.add(defaultExpr);
                                                                        }
                                                                        TWhenClauseItemList list = expr.getWhenClauseItemList();
                                                                        for (int k = 0; k < list.size(); k++) {
                                                                                TWhenClauseItem element = list.getWhenClauseItem(k);
                                                                                directExpressions.add(element.getReturn_expr());
                                                                        }
                                                                        
                                                                        for (int k = 0; k < directExpressions.size(); k++) {
                                                                                columnsInExpr visitor = new columnsInExpr();
                                                                                directExpressions.get(k).inOrderTraverse(visitor);
                                                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                                                if (objectNames == null) {
                                                                                        continue;
                                                                                }
                                                                                for (int x = 0; x < objectNames.size(); x++) {
                                                                                        String objectName = getColumnName(objectNames.get(x));
                                                                                        int link = sourceColumn.starLinkIndexOf(objectNames.get(x));
                                                                                        if (link >= 0) {

                                                                                                if(sourceColumn.getResultSet()!=null && sourceColumn.getResultSet().getColumns()!=null) {
                                                                                                        boolean find = false;
                                                                                                        for(ResultColumn column: sourceColumn.getResultSet().getColumns()) {
                                                                                                                if(SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, column.getName(), rawColumnSpelling(objectNames.get(x)))) {
                                                                                                                        source = new sourceColumn();
                                                                                                                        source.setId(String.valueOf(column.getId()));
                                                                                                                        source.setColumn(objectName);
                                                                                                                        source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                                                                                        source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                                                                                        setSourceCoordinate(source, sourceItem, sourceColumn);
                                                                                                                        append = true;
                                                                                                                        relationElement.addSource(source);
                                                                                                                        find = true;
                                                                                                                        break;
                                                                                                                }
                                                                                                        }
                                                                                                        if(find) {
                                                                                                                continue;
                                                                                                        }
                                                                                                }
                                                                                                
                                                                                                source.setId(String.valueOf(sourceColumn.getId()) + "_" + link);
                                                                                                source.setColumn(sourceColumn.starLinkName(link));
                                                                                        } else {
                                                                                                source.setId(String.valueOf(sourceColumn.getId()));
                                                                                                source.setColumn(sourceColumn.getName());
                                                                                        }
                                                                                        source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                                                        source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                                                        setSourceCoordinate(source, sourceItem, sourceColumn);
                                                                                        append = true;
                                                                                        relationElement.addSource(source);
                                                                                }
                                                                        }
                                                                } else {
                                                                        String objectName = LegacyDlineageWireNamesV1.columnName(DlineageUtil.columnSegmentOf(targetName));
                                                                        boolean find = false;
                                                                        // a star read at a position its members' unknown order cannot tell: only an explicit
                                                                        // reference names a member, never the target's own name (Mantis 4856)
                                                                        boolean positionUnproven = sourceItem instanceof ResultColumnRelationshipElement
                                                                                        && ((ResultColumnRelationshipElement) sourceItem).isPositionUnproven();

                                                                        int targetLink = positionUnproven ? -1 : sourceColumn.starLinkIndexOf(
                                                                                        targetElement instanceof Column ? (Column) targetElement : null, objectName);
                                                                        if (!find && targetLink >= 0) {
                                                                                source.setId(String.valueOf(sourceColumn.getId()) + "_" + targetLink);
                                                                                source.setColumn(sourceColumn.starLinkName(targetLink));
                                                                                find = true;
                                                                        }

                                                                        if (!find && sourceColumnName != null) {
                                                                                objectName = getColumnName(sourceColumnName);
                                                                                
                                                                                if(sourceColumn.getResultSet()!=null && sourceColumn.getResultSet().getColumns()!=null) {
                                                                                        for(ResultColumn column: sourceColumn.getResultSet().getColumns()) {
                                                                                                if(SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, column.getName(), rawColumnSpelling(sourceColumnName))) {
                                                                                                        source = new sourceColumn();
                                                                                                        source.setId(String.valueOf(column.getId()));
                                                                                                        source.setColumn(objectName);
                                                                                                        source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                                                                        source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                                                                        setSourceCoordinate(source, sourceItem, sourceColumn);
                                                                                                        append = true;
                                                                                                        relationElement.addSource(source);
                                                                                                        find = true;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                        if(find) {
                                                                                                continue;
                                                                                        }
                                                                                }
                                                                                
                                                                                int link = sourceColumn.starLinkIndexOf(sourceColumnName);
                                                                                if (link >= 0) {
                                                                                        source.setId(String.valueOf(sourceColumn.getId()) + "_" + link);
                                                                                        source.setColumn(sourceColumn.starLinkName(link));
                                                                                        find = true;
                                                                                }
                                                                        }
                                                                        
                                                                        if (!find && sourceItem instanceof ResultColumnRelationshipElement) {
                                                                                int starIndex = ((ResultColumnRelationshipElement) sourceItem)
                                                                                                .getStarIndex();
                                                                                if (starIndex > -1 && sourceColumn.getStarLinkColumnList().size() > starIndex) {
                                                                                        objectName = getColumnName(sourceColumn.getStarLinkColumnList().get(starIndex));
                                                                                        source.setId(String.valueOf(sourceColumn.getId()) + "_"
                                                                                                        + starIndex);
                                                                                        source.setColumn(objectName);
                                                                                        find = true;
                                                                                }
                                                                        }

                                                                        // A column list (CTAS, view, CTE) binds by position, and before normal
                                                                        // names were collision-free its names met the star's links through the
                                                                        // legacy fold: Snowflake "a_col" met the link of a_col. Where no link
                                                                        // carries the target's own name, keep that match rather than fan the
                                                                        // target out to the whole star.
                                                                        List<String> legacyLinks = find || sourceColumnName != null || positionUnproven
                                                                                        ? Collections.<String>emptyList()
                                                                                        : legacyStarLinks(sourceStarColumnNames, targetName);
                                                                        if (!legacyLinks.isEmpty()) {
                                                                                objectName = legacyLinks.get(0);
                                                                                source.setId(String.valueOf(sourceColumn.getId()) + "_"
                                                                                                + sourceStarColumnNames.indexOf(objectName));
                                                                                source.setColumn(objectName);
                                                                                find = true;
                                                                        }

                                                                        if (!find) {
                                                                                source.setId(String.valueOf(sourceColumn.getId()));
                                                                                source.setColumn(sourceColumn.getName());
                                                                                source.setPositionUnproven(positionUnproven);
                                                                        }

                                                                        source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                                        source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                                        setSourceCoordinate(source, sourceItem, sourceColumn);
                                                                        append = true;
                                                                        relationElement.addSource(source);
                                                                        for (int m = 1; m < legacyLinks.size(); m++) {
                                                                                sourceColumn legacySource = new sourceColumn();
                                                                                legacySource.setId(String.valueOf(sourceColumn.getId()) + "_"
                                                                                                + sourceStarColumnNames.indexOf(legacyLinks.get(m)));
                                                                                legacySource.setColumn(legacyLinks.get(m));
                                                                                legacySource.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                                                legacySource.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                                                setSourceCoordinate(legacySource, sourceItem, sourceColumn);
                                                                                relationElement.addSource(legacySource);
                                                                        }
                                                                }
                                                        }

                                                } else {
                                                        sourceColumn source = new sourceColumn();
                                                        source.setId(String.valueOf(sourceColumn.getId()));
                                                        source.setColumn(sourceColumn.getName());
                                                        source.setStruct(sourceColumn.isStruct());
                                                        source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                        source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                        setSourceCoordinate(source, sourceItem, sourceColumn);
                                                        append = true;
                                                        if (sourceItem.getTransforms() != null) {
                                                                for (Transform transform : sourceItem.getTransforms()) {
                                                                        source.addTransform(transform);
                                                                }
                                                        }
                                                        if(sourceColumn.isPseduo()) {
                                                                source.setSource("system");
                                                        }
                                                        relationElement.addSource(source);
                                                }
                                        } else if (sourceElement instanceof TableColumn) {
                                                TableColumn sourceColumn = (TableColumn) sourceElement;
                                                if (!sourceColumn.isPseduo() && sourceColumn.hasStarLinkColumn()
                                                                && sourceItem instanceof TableColumnRelationshipElement) {
                                                        sourceColumn source = new sourceColumn();
                                                        boolean find = false;
                                                        if (((TableColumnRelationshipElement) sourceItem).getColumnIndex() != null) {
                                                                int columnIndex = ((TableColumnRelationshipElement) sourceItem).getColumnIndex();
                                                                if (sourceColumn.starLinkCount() > columnIndex) {
                                                                        source = new sourceColumn();
                                                                        source.setId(String.valueOf(sourceColumn.getId()) + "_" + columnIndex);
                                                                        String targetObjectName = getColumnName(
                                                                                        sourceColumn.getStarLinkColumnList().get(columnIndex));
                                                                        source.setColumn(targetObjectName);
                                                                        source.setParent_id(String.valueOf(sourceColumn.getTable().getId()));
                                                                        source.setParent_name(sourceColumn.getTable().getName());
                                                                        if (sourceItem instanceof TableColumnRelationshipElement) {
                                                                                source.setParent_alias(
                                                                                                ((TableColumnRelationshipElement) sourceItem).getTableAlias());
                                                                        }
                                                                        setSourceCoordinate(source, sourceItem, sourceColumn);
                                                                        append = true;
                                                                        relationElement.addSource(source);
                                                                        find = true;
                                                                }
                                                        }

                                                        if (!find) {
                                                                String objectName = LegacyDlineageWireNamesV1.columnName(DlineageUtil.columnSegmentOf(targetName));

                                                                table tableElement = null;
                                                                if (dataflow.getTables() != null) {
                                                                        for (table t : dataflow.getTables()) {
                                                                                if (t.getId().equals(String.valueOf(sourceColumn.getTable().getId()))) {
                                                                                        tableElement = t;
                                                                                        break;
                                                                                }
                                                                        }
                                                                }
                                                                if (tableElement == null && dataflow.getViews() != null) {
                                                                        for (table t : dataflow.getViews()) {
                                                                                if (t.getId().equals(String.valueOf(sourceColumn.getTable().getId()))) {
                                                                                        tableElement = t;
                                                                                        break;
                                                                                }
                                                                        }
                                                                }
                                                                if (tableElement == null && dataflow.getVariables() != null) {
                                                                        for (table t : dataflow.getVariables()) {
                                                                                if (t.getId().equals(String.valueOf(sourceColumn.getTable().getId()))) {
                                                                                        tableElement = t;
                                                                                        break;
                                                                                }
                                                                        }
                                                                }

                                                                if(tableElement!=null) {
                                                                        for (column column : tableElement.getColumns()) {
                                                                                // A star target names no column: the table's column named * is not it.
                                                                                if (column.getName() != null && column.standsForStar() == targetIsStar
                                                                                                && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, column.getName(), DlineageUtil.columnSegmentOf(targetName))) {
                                                                                        source = new sourceColumn();
                                                                                        source.setId(String.valueOf(column.getId()));
                                                                                        source.setColumn(objectName);
                                                                                        source.setParent_id(String.valueOf(sourceColumn.getTable().getId()));
                                                                                        source.setParent_name(sourceColumn.getTable().getName());
                                                                                        if (sourceItem instanceof TableColumnRelationshipElement) {
                                                                                                source.setParent_alias(
                                                                                                                ((TableColumnRelationshipElement) sourceItem).getTableAlias());
                                                                                        }
                                                                                        setSourceCoordinate(source, sourceItem, sourceColumn);
                                                                                        if (sourceItem.getTransforms() != null) {
                                                                                                for (Transform transform : sourceItem.getTransforms()) {
                                                                                                        source.addTransform(transform);
                                                                                                }
                                                                                        }
                                                                                        if (sourceColumn.getCandidateParents() != null) {
                                                                                                for(Object item: sourceColumn.getCandidateParents()) {
                                                                                                        candidateTable candidateParent = new candidateTable();
                                                                                                        if(item instanceof Table) {
                                                                                                                candidateParent.setId(String.valueOf(((Table)item).getId()));
                                                                                                                candidateParent.setName(getTableName((Table)item));
                                                                                                                source.addCandidateParent(candidateParent);
                                                                                                        }
                                                                                                        else if(item instanceof ResultSet) {
                                                                                                                candidateParent.setId(String.valueOf(((ResultSet)item).getId()));
                                                                                                                candidateParent.setName(getResultSetName((ResultSet)item));
                                                                                                                source.addCandidateParent(candidateParent);
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                        append = true;
                                                                                        relationElement.addSource(source);
                                                                                        find = true;
                                                                                        break;
                                                                                }
                                                                        }
                                                                }
                                                        }

                                                        if(!find) {
                                                                source = new sourceColumn();
                                                                source.setId(String.valueOf(sourceColumn.getId()));
                                                                source.setColumn(sourceColumn.getName());
                                                                source.setParent_id(String.valueOf(sourceColumn.getTable().getId()));
                                                                source.setParent_name(sourceColumn.getTable().getName());
                                                                if (sourceItem instanceof TableColumnRelationshipElement) {
                                                                        source.setParent_alias(
                                                                                        ((TableColumnRelationshipElement) sourceItem).getTableAlias());
                                                                }
                                                                setSourceCoordinate(source, sourceItem, sourceColumn);
                                                                if (sourceItem.getTransforms() != null) {
                                                                        for (Transform transform : sourceItem.getTransforms()) {
                                                                                source.addTransform(transform);
                                                                        }
                                                                }
                                                                if (sourceColumn.getCandidateParents() != null) {
                                                                        for(Object item: sourceColumn.getCandidateParents()) {
                                                                                candidateTable candidateParent = new candidateTable();
                                                                                if(item instanceof Table) {
                                                                                        candidateParent.setId(String.valueOf(((Table)item).getId()));
                                                                                        candidateParent.setName(getTableName((Table)item));
                                                                                        source.addCandidateParent(candidateParent);
                                                                                }
                                                                                else if(item instanceof ResultSet) {
                                                                                        candidateParent.setId(String.valueOf(((ResultSet)item).getId()));
                                                                                        candidateParent.setName(getResultSetName((ResultSet)item));
                                                                                        source.addCandidateParent(candidateParent);
                                                                                }
                                                                        }
                                                                }
                                                                append = true;
                                                                relationElement.addSource(source);
                                                        }

                                                } else {
                                                        sourceColumn source = new sourceColumn();
                                                        source.setId(String.valueOf(sourceColumn.getId()));
                                                        source.setColumn(sourceColumn.getName());
                                                        source.setStruct(sourceColumn.isStruct());
                                                        source.setParent_id(String.valueOf(sourceColumn.getTable().getId()));
                                                        source.setParent_name(getTableName(sourceColumn.getTable()));
                                                        if (sourceItem instanceof TableColumnRelationshipElement) {
                                                                source.setParent_alias(
                                                                                ((TableColumnRelationshipElement) sourceItem).getTableAlias());
                                                        }
                                                        setSourceCoordinate(source, sourceItem, sourceColumn);
                                                        if (sourceItem.getTransforms() != null) {
                                                                for (Transform transform : sourceItem.getTransforms()) {
                                                                        source.addTransform(transform);
                                                                }
                                                        }
                                                        if(sourceColumn.isPseduo()) {
                                                                source.setSource("system");
                                                        }
                                                        if (sourceColumn.getCandidateParents() != null) {
                                                                for(Object item: sourceColumn.getCandidateParents()) {
                                                                        candidateTable candidateParent = new candidateTable();
                                                                        if(item instanceof Table) {
                                                                                candidateParent.setId(String.valueOf(((Table)item).getId()));
                                                                                candidateParent.setName(getTableName((Table)item));
                                                                                source.addCandidateParent(candidateParent);
                                                                        }
                                                                        else if(item instanceof ResultSet) {
                                                                                candidateParent.setId(String.valueOf(((ResultSet)item).getId()));
                                                                                candidateParent.setName(getResultSetName((ResultSet)item));
                                                                                source.addCandidateParent(candidateParent);
                                                                        }
                                                                }
                                                        }
                                                        append = true;
                                                        relationElement.addSource(source);
                                                }
                                        } else if (sourceElement instanceof Argument) {
                                                Argument sourceColumn = (Argument) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setId(String.valueOf(sourceColumn.getId()));
                                                source.setColumn(sourceColumn.getName());
                                                source.setParent_id(String.valueOf(sourceColumn.getProcedure().getId()));
                                                source.setParent_name(sourceColumn.getProcedure().getName());
                                                if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                        + convertCoordinate(sourceColumn.getEndPosition()));
                                                }
                                                append = true;
                                                relationElement.addSource(source);
                                        } else if (sourceElement instanceof TableRelationRows) {
                                                TableRelationRows sourceColumn = (TableRelationRows) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setId(String.valueOf(sourceColumn.getId()));
                                                source.setColumn(sourceColumn.getName());
                                                source.setParent_id(String.valueOf(sourceColumn.getHolder().getId()));
                                                source.setParent_name(getTableName(sourceColumn.getHolder()));
                                                if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                        + convertCoordinate(sourceColumn.getEndPosition()));
                                                }
                                                source.setSource("system");
                                                append = true;
                                                relationElement.addSource(source);
                                        } else if (sourceElement instanceof ResultSetRelationRows) {
                                                ResultSetRelationRows sourceColumn = (ResultSetRelationRows) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setId(String.valueOf(sourceColumn.getId()));
                                                source.setColumn(sourceColumn.getName());
                                                source.setParent_id(String.valueOf(sourceColumn.getHolder().getId()));
                                                source.setParent_name(getResultSetName(sourceColumn.getHolder()));
                                                if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                        + convertCoordinate(sourceColumn.getEndPosition()));
                                                }
                                                source.setSource("system");
                                                append = true;
                                                relationElement.addSource(source);
                                        } else if (sourceElement instanceof Constant) {
                                                Constant sourceColumn = (Constant) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setId(String.valueOf(sourceColumn.getId()));
                                                source.setColumn(sourceColumn.getName());
                                                source.setColumn_type("constant");
                                                if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                        + convertCoordinate(sourceColumn.getEndPosition()));
                                                }
                                                append = true;
                                                relationElement.addSource(source);
                                        } else if (sourceElement instanceof Table) {
                                                Table table = (Table) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setSource_id(String.valueOf(table.getId()));
                                                source.setSource_name(getTableName(table));
                                                if (table.getStartPosition() != null && table.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(table.getStartPosition()) + ","
                                                                        + convertCoordinate(table.getEndPosition()));
                                                }
                                                append = true;
                                                relationElement.addSource(source);
                                        }

                                        if (relation instanceof ImpactRelationship) {
                                                ESqlClause clause = getSqlClause(sourceItem);
                                                if (clause != null
                                                                && (relationElement.getSources() != null && !relationElement.getSources().isEmpty())) {
                                                        relationElement.getSources().get(relationElement.getSources().size() - 1)
                                                                        .setClauseType(clause.name());
                                                }
                                        }
                                }
                                if (append)
                                        dataflow.getRelationships().add(relationElement);
                        }
                }
        }

        private boolean containsStar(Collection<RelationshipElement<?>> elements) {
                if (elements == null || elements.size() == 0)
                        return false;

                for (RelationshipElement<?> element : elements) {
                        if (element.getElement() instanceof ResultColumn) {
                                ResultColumn object = (ResultColumn) element.getElement();
                                if (object.isStarColumn() && object.isShowStar())
                                        return true;
                        } else if (element.getElement() instanceof TableColumn) {
                                TableColumn object = (TableColumn) element.getElement();
                                if (object.isStarColumn() && object.isShowStar())
                                        return true;
                        }
                }
                return false;
        }

        private Map<String, Set<String>> appendTableStarColumns = new HashMap<String, Set<String>>();

        // Tracks column names that have explicit (non-star) sources per target star column.
        // Used across relationships to prevent phantom star expansions.
        // Key: target star column ID, Value: set of column names with explicit sources.
        private Map<Long, StarLinkNameSet> explicitStarTargetColumns = new HashMap<Long, StarLinkNameSet>();
        /**
         * Remove from a SELECT-list star's expansion the columns its own EXCEPT / EXCLUDE clause takes
         * out -- BigQuery {@code SELECT * EXCEPT (a)}, Snowflake {@code SELECT * EXCLUDE (a)}.
         *
         * <p>Only the PROJECTION changes. The column stays a column of its table: naming it in
         * {@code EXCEPT} is proof that it exists there, and the table's own {@code *} still covers it.
         * What the clause proves is the narrower fact that this star does not project it.
         *
         * <p>Routed through {@link ResultColumn#unbindStarLinkColumn} rather than comparing names here,
         * because that method owns how a star-link key is derived from a {@link TObjectName}; a second
         * copy of that rule in this file would drift from the one analyzeSelectStmt already uses.
         *
         * @param starColumn the result column a star produced; anything else is left alone
         */
        private void unbindExceptedStarColumns(ResultColumn starColumn) {
                if (starColumn == null || !(starColumn.getColumnObject() instanceof TResultColumn)) {
                        return;
                }
                TObjectNameList exceptColumns =
                                ((TResultColumn) starColumn.getColumnObject()).getExceptColumnList();
                if (exceptColumns == null) {
                        return;
                }
                for (TObjectName exceptColumn : exceptColumns) {
                        starColumn.unbindStarLinkColumn(exceptColumn);
                }
        }

        private void updateResultColumnStarLinks(dataflow dataflow, AbstractRelationship relation, int index) {
        try {
            if (option.getAnalyzeMode() == AnalyzeMode.crud) {
                return;
            }

            ResultColumn targetColumn = (ResultColumn) relation.getTarget().getElement();

            Collection<RelationshipElement<?>> sourceElements = (Collection<RelationshipElement<?>>) relation.getSources();
            if (sourceElements == null || sourceElements.size() == 0)
                return;

            for (RelationshipElement<?> sourceItem : sourceElements) {
                Object sourceElement = sourceItem.getElement();
                if (sourceElement instanceof ResultColumn) {
                    ResultColumn source = (ResultColumn) sourceElement;
                    if (source.hasStarLinkColumn()) {
                        targetColumn.mergeStarLinksFrom(source);
                        if (!source.isShowStar()) {
                            targetColumn.setShowStar(false);
                            relation.setShowStarRelation(false);
                        }
                    } else if (!source.isStarColumn()) {
                        if (source.getColumnObject() instanceof TObjectName) {
                            if (source instanceof FunctionResultColumn) {

                            } else {
                                targetColumn.bindStarLinkColumn((TObjectName) source.getColumnObject());
                            }
                        } else if (source.getColumnObject() instanceof TResultColumn) {
                            TResultColumn sourceColumn = (TResultColumn) source.getColumnObject();
                            if (sourceColumn.getAliasClause() != null) {
                                targetColumn.bindStarLinkColumn(sourceColumn.getAliasClause().getAliasName());
                            } else if (sourceColumn.getFieldAttr() != null) {
                                targetColumn.bindStarLinkColumn(sourceColumn.getFieldAttr());
                            } else {
                                TObjectName column = Column.nameOfColumn(source,
                                        sourceColumn.getExpr().getExpressionType() == EExpressionType.typecast_t
                                                ? sourceColumn.getExpr().getLeftOperand().toString()
                                                : sourceColumn.toString());
                                targetColumn.bindStarLinkColumn(column);
                            }
                        }
                    }
                } else if (sourceElement instanceof TableColumn && !targetColumn.isStruct()) {
                    TableColumn source = (TableColumn) sourceElement;
                    if (!source.isPseduo() && source.hasStarLinkColumn()) {
                                                targetColumn.mergeStarLinksFrom(source);
                                                if ((source.getTable().isCreateTable() || source.getTable().hasSQLEnv())
                                                                && !source.isShowStar()) {
                                                        targetColumn.setShowStar(false);
                                                        relation.setShowStarRelation(false);
                                                }
                    } else if (!source.isStarColumn()) {
                        targetColumn.bindStarLinkColumn(source.getColumnObject());
                    }
                }
            }

            // Re-apply this star's own EXCEPT / EXCLUDE list to the expansion just merged in.
            //
            // analyzeSelectStmt already filters it (bind each learned column, then
            // unbindStarLinkColumn every EXCEPT name), but the merges above copy another column's
            // expansion in through the raw starLinkColumns map instead of through
            // bindStarLinkColumn, which puts the removed names back. A table's own "*" legitimately
            // covers every column of that table -- EXCEPT (x) is itself proof that x IS a column
            // there -- so the table side must not change; what must not happen is x re-entering the
            // projection of a SELECT-list star that provably does not project it.
            unbindExceptedStarColumns(targetColumn);

            if (targetColumn.hasStarLinkColumn()) {
                table resultSetElement = null;
                for (table t : dataflow.getResultsets()) {
                    if (t.getId().equals(String.valueOf(targetColumn.getResultSet().getId()))) {
                        resultSetElement = t;
                        break;
                    }
                }

                int starColumnCount = 0;
                for (column item : resultSetElement.getColumns()) {
                    if (item.standsForStar()) {
                        starColumnCount += 1;
                    }
                }

                if (resultSetElement != null && starColumnCount <= 1) {
                    List<String> columns = targetColumn.getStarLinkColumnNames();
                    if (index == -1) {
                        for (int k = 0; k < columns.size(); k++) {
                            String columnName = columns.get(k);
                            String id = String.valueOf(targetColumn.getId()) + "_" + k;
                            if (appendTableStarColumns.containsKey(resultSetElement.getId()) && appendTableStarColumns.get(resultSetElement.getId()).contains(id)) {
                                continue;
                            }
                            column columnElement = new column();
                            columnElement.setId(id);
                            columnElement.setIdentifierKey(targetColumn.starLinkIdentifier(k));
                            columnElement.setSqlSpelling(targetColumn.starLinkSqlSpelling(k));
                            columnElement.setName(columnName);
                            if (targetColumn.isFunction()) {
                                columnElement.setIsFunction(String.valueOf(targetColumn.isFunction()));
                            }
                            if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                columnElement.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                        + convertCoordinate(targetColumn.getEndPosition()));
                            }

                            if (targetColumn.getResultSet() != null && targetColumn.getResultSet().getColumns() != null) {
                                boolean find = false;
                                for (int i = 0; i < targetColumn.getResultSet().getColumns().size(); i++) {
                                    ResultColumn columnModel = targetColumn.getResultSet().getColumns().get(i);
                                    if (targetColumn.starLinkNamesColumn(k, columnModel)) {
                                        find = true;
                                        break;
                                    }
                                }
                                if (find) {
                                    continue;
                                }
                            }

                            if (!resultSetElement.getColumns().contains(columnElement)) {
                                resultSetElement.getColumns().add(columnElement);
                                appendTableStarColumns.putIfAbsent(resultSetElement.getId(), new HashSet<String>());
                                appendTableStarColumns.get(resultSetElement.getId()).add(id);
                            }
                        }
                    } else {
                        int k = index;
                        String columnName = columns.get(k);
                        column columnElement = new column();
                        columnElement.setId(String.valueOf(targetColumn.getId()) + "_" + k);
                        columnElement.setIdentifierKey(targetColumn.starLinkIdentifier(k));
                        columnElement.setSqlSpelling(targetColumn.starLinkSqlSpelling(k));
                        columnElement.setName(columnName);
                        if (targetColumn.isFunction()) {
                            columnElement.setIsFunction(String.valueOf(targetColumn.isFunction()));
                        }
                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                            columnElement.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                    + convertCoordinate(targetColumn.getEndPosition()));
                        }

                        if (targetColumn.getResultSet() != null && targetColumn.getResultSet().getColumns() != null) {
                            boolean find = false;
                            for (int i = 0; i < targetColumn.getResultSet().getColumns().size(); i++) {
                                ResultColumn columnModel = targetColumn.getResultSet().getColumns().get(i);
                                if (targetColumn.starLinkNamesColumn(k, columnModel)) {
                                    find = true;
                                    break;
                                }
                            }
                            if (find) {
                                return;
                            }
                        }

                        if (!resultSetElement.getColumns().contains(columnElement)) {
                            resultSetElement.getColumns().add(columnElement);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error("updateResultColumnStarLinks occurs unknown exceptions.", e);
        }
        }

        private void updateTableColumnStarLinks(dataflow dataflow, AbstractRelationship relation) {
                TableColumn targetColumn = (TableColumn) relation.getTarget().getElement();             
                Collection<RelationshipElement<?>> sourceElements = (Collection<RelationshipElement<?>>) relation.getSources();
                if (sourceElements == null || sourceElements.size() == 0)
                        return;

                TableColumn sourceStarColumn = null;

                for (RelationshipElement<?> sourceItem: sourceElements) {
                        Object sourceElement = sourceItem.getElement();
                        if (sourceElement instanceof ResultColumn) {
                                ResultColumn source = (ResultColumn) sourceElement;
                                if(source.getResultSet() instanceof Function) {
                                        continue;
                                }
                                if (source.hasStarLinkColumn()) {
                                        targetColumn.mergeStarLinksFrom(source);
                                        if (!source.isShowStar()) {
                                                targetColumn.setShowStar(false);
                                                relation.setShowStarRelation(false);
                                        }
                                } else if (!source.isStarColumn()) {
                                        if (source.getColumnObject() instanceof TObjectName) {
                                                targetColumn.bindStarLinkColumn((TObjectName) source.getColumnObject());
                                        } else if (source.getColumnObject() instanceof TResultColumn) {
                                                if (((TResultColumn) source.getColumnObject()).getAliasClause() != null) {
                                                        TObjectName field = ((TResultColumn) source.getColumnObject()).getAliasClause()
                                                                        .getAliasName();
                                                        if (field != null) {
                                                                targetColumn.bindStarLinkColumn(field);
                                                        }
                                                } else {
                                                        TObjectName field = ((TResultColumn) source.getColumnObject()).getFieldAttr();
                                                        if (field != null) {
                                                                targetColumn.bindStarLinkColumn(field);
                                                        } else {
                                                                TObjectName column = Column.nameOfColumn(source,
                                                                                ((TResultColumn) source.getColumnObject()).getExpr()
                                                                                                .getExpressionType() == EExpressionType.typecast_t
                                                                                                ? ((TResultColumn) source.getColumnObject()).getExpr().getLeftOperand().toString()
                                                                                                : ((TResultColumn) source.getColumnObject()).toString());
                                                                targetColumn.bindStarLinkColumn(column);
                                                        }
                                                }
                                        }
                                }
                        } else if (sourceElement instanceof TableColumn) {
                                TableColumn source = (TableColumn) sourceElement;
                                if (source.hasStarLinkColumn()) {
                                        targetColumn.mergeStarLinksFrom(source);
                                        source.mergeStarLinksFrom(targetColumn);

                                        sourceStarColumn = source;

                                        if (source.getTable().isCreateTable() && !source.isShowStar()) {
                                                targetColumn.setShowStar(false);
                                                relation.setShowStarRelation(false);
                                        }
                                } else if (!source.isStarColumn()) {
                                        if (source.isStruct()) {
                                                targetColumn.bindStarLinkColumn(source.getColumnObject());
                                        }
                                        else {
                                                TObjectName objectName = Column.nameOfColumn(source, DlineageUtil.getColumnNameOnly(source.getName()));
                                                targetColumn.bindStarLinkColumn(objectName);
                                        }
                                }
                        }
                }

                if (targetColumn.hasStarLinkColumn()) {
                        table tableElement = null;
                        if (dataflow.getTables() != null) {
                                for (table t : dataflow.getTables()) {
                                        if (t.getId().equals(String.valueOf(targetColumn.getTable().getId()))) {
                                                tableElement = t;
                                                break;
                                        }
                                }
                        }
                        if (tableElement == null && dataflow.getViews() != null) {
                                for (table t : dataflow.getViews()) {
                                        if (t.getId().equals(String.valueOf(targetColumn.getTable().getId()))) {
                                                tableElement = t;
                                                break;
                                        }
                                }
                        }
                        if (tableElement == null && dataflow.getVariables() != null) {
                                for (table t : dataflow.getVariables()) {
                                        if (t.getId().equals(String.valueOf(targetColumn.getTable().getId()))) {
                                                tableElement = t;
                                                break;
                                        }
                                }
                        }

                        if (tableElement != null) {
                                List<String> columns = targetColumn.getStarLinkColumnNames();
                                for (int k = 0; k < columns.size(); k++) {
                                        String columnName = columns.get(k);
                                        if (containStarColumn(targetColumn.getTable().getColumns(), targetColumn, k)) {
                                                continue;
                                        }
                                        column columnElement = new column();
                                        columnElement.setId(String.valueOf(targetColumn.getId()) + "_" + k);
                                        columnElement.setIdentifierKey(targetColumn.starLinkIdentifier(k));
                                        columnElement.setSqlSpelling(targetColumn.starLinkSqlSpelling(k));
                                        columnElement.setName(columnName);
                                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                                + convertCoordinate(targetColumn.getEndPosition()));
                                        }
                                        if (!tableElement.getColumns().contains(columnElement)) {
                                                tableElement.getColumns().add(columnElement);
                                        }
                                }
                        }
                }

                if (sourceStarColumn != null) {
                        table tableElement = null;
                        if (dataflow.getTables() != null) {
                                for (table t : dataflow.getTables()) {
                                        if (t.getId().equals(String.valueOf(sourceStarColumn.getTable().getId()))) {
                                                tableElement = t;
                                                break;
                                        }
                                }
                        }
                        if (tableElement == null && dataflow.getViews() != null) {
                                for (table t : dataflow.getViews()) {
                                        if (t.getId().equals(String.valueOf(sourceStarColumn.getTable().getId()))) {
                                                tableElement = t;
                                                break;
                                        }
                                }
                        }
                        if (tableElement == null && dataflow.getVariables() != null) {
                                for (table t : dataflow.getVariables()) {
                                        if (t.getId().equals(String.valueOf(sourceStarColumn.getTable().getId()))) {
                                                tableElement = t;
                                                break;
                                        }
                                }
                        }

                        if (tableElement != null) {
                                List<String> columns = sourceStarColumn.getStarLinkColumnNames();
                                for (int k = 0; k < columns.size(); k++) {
                                        String columnName = columns.get(k);
                                        if (containStarColumn(sourceStarColumn.getTable().getColumns(), sourceStarColumn, k)) {
                                                continue;
                                        }
                                        column columnElement = new column();
                                        columnElement.setId(sourceStarColumn.getId() + "_" + k);
                                        columnElement.setIdentifierKey(sourceStarColumn.starLinkIdentifier(k));
                                        columnElement.setSqlSpelling(sourceStarColumn.starLinkSqlSpelling(k));
                                        columnElement.setName(columnName);
                                        if (sourceStarColumn.getStartPosition() != null && sourceStarColumn.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(sourceStarColumn.getStartPosition()) + ","
                                                                + convertCoordinate(sourceStarColumn.getEndPosition()));
                                        }
                                        if (!tableElement.getColumns().contains(columnElement)) {
                                                tableElement.getColumns().add(columnElement);
                                        }
                                }
                        }
                }
        }

        private ESqlClause getSqlClause(RelationshipElement<?> relationshipElement) {
                if (relationshipElement instanceof TableColumnRelationshipElement) {
                        return ((TableColumnRelationshipElement) relationshipElement).getRelationLocation();
                } else if (relationshipElement instanceof ResultColumnRelationshipElement) {
                        return ((ResultColumnRelationshipElement) relationshipElement).getRelationLocation();
                }
                return null;
        }

        /**
         * Emits a source coordinate, preferring the relationship element's own
         * reference site (where THIS relation referenced the column — e.g. the
         * ON/WHERE operand) over the shared column model's position. A created
         * (e.g. #temp) table reuses one TableColumn model for the definition and
         * every reference, so the model's position alone would report the
         * definition site for every operand.
         */
        private void setSourceCoordinate(sourceColumn source, RelationshipElement<?> sourceItem,
                        TableColumn sourceTableColumn) {
                Pair3<Long, Long, String> modelStart = sourceTableColumn.getStartPosition();
                Pair3<Long, Long, String> modelEnd = sourceTableColumn.getEndPosition();
                Pair3<Long, Long, String> start = modelStart;
                Pair3<Long, Long, String> end = modelEnd;
                if (sourceItem instanceof TableColumnRelationshipElement) {
                        TableColumnRelationshipElement element = (TableColumnRelationshipElement) sourceItem;
                        if (element.getReferenceStartPosition() != null && element.getReferenceEndPosition() != null) {
                                start = element.getReferenceStartPosition();
                                end = element.getReferenceEndPosition();
                                if (modelStart != null && modelEnd != null) {
                                        // Keep the definition span for the merge pass's dedup steps.
                                        source.setDedupCoordinate(convertCoordinate(modelStart) + "," + convertCoordinate(modelEnd));
                                }
                        }
                }
                if (start != null && end != null) {
                        source.setCoordinate(convertCoordinate(start) + "," + convertCoordinate(end));
                }
        }

        /**
         * ResultColumn flavor of {@link #setSourceCoordinate}: a derived table's /
         * CTE's result column model carries its select-list definition span, so the
         * relationship element's reference site (the ON/WHERE operand) wins when it
         * was captured.
         */
        private void setSourceCoordinate(sourceColumn source, RelationshipElement<?> sourceItem,
                        ResultColumn sourceResultColumn) {
                Pair3<Long, Long, String> modelStart = sourceResultColumn.getStartPosition();
                Pair3<Long, Long, String> modelEnd = sourceResultColumn.getEndPosition();
                Pair3<Long, Long, String> start = modelStart;
                Pair3<Long, Long, String> end = modelEnd;
                if (sourceItem instanceof ResultColumnRelationshipElement) {
                        ResultColumnRelationshipElement element = (ResultColumnRelationshipElement) sourceItem;
                        if (element.getReferenceStartPosition() != null && element.getReferenceEndPosition() != null) {
                                start = element.getReferenceStartPosition();
                                end = element.getReferenceEndPosition();
                                if (modelStart != null && modelEnd != null) {
                                        // Keep the definition span for the merge pass's dedup steps.
                                        source.setDedupCoordinate(convertCoordinate(modelStart) + "," + convertCoordinate(modelEnd));
                                }
                        }
                }
                if (start != null && end != null) {
                        source.setCoordinate(convertCoordinate(start) + "," + convertCoordinate(end));
                }
        }

        private void appendStarRelation(dataflow dataflow, AbstractRelationship relation, int index) {
                if(option.getAnalyzeMode() == AnalyzeMode.crud) {
                        return;
                }
                
                Object targetElement = relation.getTarget().getElement();

                relationship relationElement = new relationship();
                relationElement.setType(relation.getRelationshipType().name());
                if (relation.getEffectType() != null) {
                        relationElement.setEffectType(relation.getEffectType().name());
                }
                relationElement.setSqlHash(relation.getSqlHash());
                relationElement.setSqlComment(relation.getSqlComment());

                if (relation.getProcedureId() != null) {
                        relationElement.setProcedureId(String.valueOf(relation.getProcedureId()));
                }
                relationElement.setId(String.valueOf(relation.getId()) + "_" + index);
                if (relation.getProcess() != null) {
                        relationElement.setProcessId(String.valueOf(relation.getProcess().getId()));
                        if (relation.getProcess().getGspObject() != null) {
                                relationElement.setProcessType(relation.getProcess().getGspObject().sqlstatementtype.name());
                        }
                }
                if (relation instanceof DataFlowRelationship) {
                        relationElement.setSqlHash(((DataFlowRelationship) relation).getSqlHash());
                        relationElement.setSqlComment(((DataFlowRelationship) relation).getSqlComment());
                
                        if (relation.getProcedureId() != null) {
                                relationElement.setProcedureId(String.valueOf(relation.getProcedureId()));
                        }
                }
                String targetName = "";
                Column targetLinkColumn = null;

                if (targetElement instanceof ResultColumn) {
                        ResultColumn targetColumn = (ResultColumn) targetElement;
                        targetLinkColumn = targetColumn;

                        targetName = targetColumn.starLinkName(index);

                        
                        targetColumn target = new targetColumn();
                        target.setId(String.valueOf(targetColumn.getId()) + "_" + index);
                        if(targetColumn.getResultSet()!=null && targetColumn.getResultSet().getColumns()!=null) {
                                ResultColumn matched = getResultSetColumnLookup(targetColumn.getResultSet().getColumns()).get(targetColumn, index);
                                if (matched != null) {
                                        target.setId(String.valueOf(matched.getId()));
                                }
                        }
                        target.setColumn(targetName);
                        target.setStruct(targetColumn.isStruct());
                        target.setParent_id(String.valueOf(targetColumn.getResultSet().getId()));
                        target.setParent_name(getResultSetName(targetColumn.getResultSet()));
                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                target.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                + convertCoordinate(targetColumn.getEndPosition()));
                        }
                        relationElement.setTarget(target);
                } else if (targetElement instanceof TableColumn) {
                        TableColumn targetColumn = (TableColumn) targetElement;
                        targetLinkColumn = targetColumn;

                        targetName = targetColumn.starLinkName(index);

                        TableColumn tableColumn = getTableColumnLookup(targetColumn.getTable().getColumns()).get(targetColumn, index);

                        targetColumn target = new targetColumn();
                        if (tableColumn == null) {
                                target.setId(targetColumn.getId() + "_" + index);
                        } else {
                                target.setId(String.valueOf(tableColumn.getId()));
                        }
                        target.setStruct(targetColumn.isStruct());
                        target.setColumn(targetName);
                        target.setParent_id(String.valueOf(targetColumn.getTable().getId()));
                        target.setParent_name(targetColumn.getTable().getName());
                        if (relation.getTarget() instanceof TableColumnRelationshipElement) {
                                target.setParent_alias(((TableColumnRelationshipElement) relation.getTarget()).getTableAlias());
                        }
                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                target.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                + convertCoordinate(targetColumn.getEndPosition()));
                        }
                        relationElement.setTarget(target);
                } else {
                        return;
                }

                Collection<RelationshipElement<?>> sourceElements = (Collection<RelationshipElement<?>>) relation.getSources();
                if (sourceElements.size() == 0) {
                        return;
                }

                StarLinkMatcher targetLink = targetLinkColumn.starLinkMatcher(index);
                if (targetLink == null) {
                        return;
                }

                // Record-fill expansion (#695): when the star being expanded is a
                // record VARIABLE's own * (holder type decided at analysis, not
                // inferred here), every field is filled by the SAME producer, so the
                // name filters below — written for SELECT-* expansion, where source
                // and target columns pair by name — must not drop it.
                // Record-fill keep-all applies to a SINGLE-source fill only: one opaque
                // producer genuinely feeds every field. A multi-source relation fanned
                // across the fields would multiply unproven field-level claims.
                boolean recordFillTarget = targetElement instanceof TableColumn
                                && ((TableColumn) targetElement).getTable() instanceof Variable
                                && relation.getSources() != null && relation.getSources().size() == 1;

                // Track explicit (non-star) source columns per target star column to prevent
                // phantom star expansions. Skip for UNION targets where branches contribute independently.
                long targetColumnId = -1;
                boolean isUnionTarget = false;
                if (targetElement instanceof ResultColumn) {
                        ResultColumn tc = (ResultColumn) targetElement;
                        targetColumnId = tc.getId();
                        isUnionTarget = (tc.getResultSet() instanceof SelectSetResultSet);
                } else if (targetElement instanceof TableColumn) {
                        targetColumnId = ((TableColumn) targetElement).getId();
                }

                if (!isUnionTarget && targetColumnId != -1) {
                        // Check if any source in this relationship is a non-star source matching the target
                        // column name, AND whose parent does NOT also contribute a star source.
                        // This distinguishes:
                        //   - "b.col_a" (definitive: b only provides explicit cols, not *) => suppress star expansion
                        //   - "aTab.id" (not definitive: aTab also provides *) => don't suppress
                        boolean hasDefinitiveExplicitSource = hasDefinitiveNonStarSource(sourceElements, targetLink);
                        if (hasDefinitiveExplicitSource) {
                                if (!explicitStarTargetColumns.containsKey(targetColumnId)) {
                                        explicitStarTargetColumns.put(targetColumnId, new StarLinkNameSet());
                                }
                                explicitStarTargetColumns.get(targetColumnId).add(targetLink);
                        }
                }

                // Column names that have explicit (non-star) sources for this target, across all relationships
                StarLinkNameSet targetExplicitNames = isUnionTarget ? null : explicitStarTargetColumns.get(targetColumnId);

                for (RelationshipElement<?> sourceItem: sourceElements) {
                        Object sourceElement = sourceItem.getElement();
                        if (sourceElement instanceof ResultColumn) {
                                ResultColumn sourceColumn = (ResultColumn) sourceElement;
                                if (sourceColumn.hasStarLinkColumn()) {
                                        List<String> linkColumnNames = sourceColumn.getStarLinkColumnNames();
                                        int linkColumnNameSize = linkColumnNames.size();
                                        for (int k = 0; k < linkColumnNameSize; k++) {
                                                String sourceName = linkColumnNames.get(k);
                                                if (relation.getRelationshipType() == RelationshipType.fdd) {
                                                        if (!targetLink.matches(sourceColumn, k))
                                                                continue;
                                                }
                                                // Skip star-expanded source when an explicit (non-star) source provides
                                                // the same column, either in this relationship or a prior one.
                                                if (targetExplicitNames != null && targetExplicitNames.contains(sourceColumn, k)) {
                                                        continue;
                                                }
                                                sourceColumn source = new sourceColumn();                                               
                                                
                                                boolean find = false;
                                                if(sourceColumn.getResultSet()!=null && sourceColumn.getResultSet().getColumns()!=null) {
                                                        ResultColumn matched = getResultSetColumnLookup(sourceColumn.getResultSet().getColumns()).get(sourceColumn, k);
                                                        if (matched != null) {
                                                                source.setId(String.valueOf(matched.getId()));
                                                                find = true;
                                                        }
                                                }
                                                if(!find) {
                                                        source.setId(String.valueOf(sourceColumn.getId()) + "_" + k);
                                                }
                                                source.setColumn(sourceName);
                                                source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                        + convertCoordinate(sourceColumn.getEndPosition()));
                                                }
                                                if (sourceItem.getTransforms() != null) {
                                                        for (Transform transform : sourceItem.getTransforms()) {
                                                                source.addTransform(transform);
                                                        }
                                                }
                                                relationElement.addSource(source);
                                        }
                                        if(relationElement.getSources().isEmpty()
                                                && !(targetExplicitNames != null && targetExplicitNames.contains(targetLink))
                                                && sourceColumn.getResultSet()!=null && sourceColumn.getResultSet().getColumns()!=null) {
                                                for (ResultColumn columnModel : getResultSetColumnLookup(sourceColumn.getResultSet().getColumns()).values()) {
                                                        if (targetLink.matchesColumn(columnModel)) {
                                                                sourceColumn source = new sourceColumn();
                                                                source.setId(String.valueOf(columnModel.getId()));
                                                                source.setColumn(columnModel.getName());
                                                                source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                                source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                                if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                                        source.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                                        + convertCoordinate(sourceColumn.getEndPosition()));
                                                                }
                                                                if (sourceItem.getTransforms() != null) {
                                                                        for (Transform transform : sourceItem.getTransforms()) {
                                                                                source.addTransform(transform);
                                                                        }
                                                                }
                                                                relationElement.addSource(source);
                                                                break;
                                                        }
                                                }
                                        }
                                        // No source link matched: the target's column is inferred to come through this star, unless the
                                        // star holds another identity's column under the same name (grouped by identity, a different
                                        // column, which this star does not also hold by inference).
                                        if (relationElement.getSources().isEmpty()
                                                && !(targetExplicitNames != null && targetExplicitNames.contains(targetLink))
                                                && !targetLink.isDisplacedIn(sourceColumn)) {
                                                TObjectName sourceStarLinkColumn = targetLinkColumn.starLinkNameNode(index);
                                                boolean newBinding = sourceColumn.bindStarLinkColumn(sourceStarLinkColumn);
                                                sourceColumn source = new sourceColumn();
                                                String sourceName = LegacyDlineageWireNamesV1.columnName(sourceStarLinkColumn);
                                                if (!newBinding) {
                                                        source.setId(String.valueOf(sourceColumn.getId()) + "_"
                                                                        + sourceColumn.indexOfStarLinkColumn(sourceStarLinkColumn));
                                                } else {
                                                        source.setId(String.valueOf(sourceColumn.getId()) + "_" + linkColumnNameSize);
                                                }
                                                source.setColumn(sourceName);
                                                source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                        + convertCoordinate(sourceColumn.getEndPosition()));
                                                }
                                                if (sourceItem.getTransforms() != null) {
                                                        for (Transform transform : sourceItem.getTransforms()) {
                                                                source.addTransform(transform);
                                                        }
                                                }
                                                relationElement.addSource(source);

                                                if (newBinding) {
                                                        table resultSetElement = null;
                                                        for (table t : dataflow.getResultsets()) {
                                                                if (t.getId().equals(String.valueOf(sourceColumn.getResultSet().getId()))) {
                                                                        resultSetElement = t;
                                                                        break;
                                                                }
                                                        }
                                                        if (resultSetElement != null) {
                                                                column columnElement = new column();
                                                                columnElement.setId(String.valueOf(sourceColumn.getId()) + "_" + linkColumnNameSize);
                                                                columnElement.setIdentifierKey(sourceColumn.starLinkIdentifier(linkColumnNameSize));
                                                                columnElement.setSqlSpelling(sourceColumn.starLinkSqlSpelling(linkColumnNameSize));
                                                                columnElement.setName(sourceName);
                                                                if (sourceColumn.isFunction()) {
                                                                        columnElement.setIsFunction(String.valueOf(sourceColumn.isFunction()));
                                                                }
                                                                if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                                        columnElement.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                                        + convertCoordinate(sourceColumn.getEndPosition()));
                                                                }
                                                                resultSetElement.getColumns().add(columnElement);
                                                        }
                                                }
                                        }
                                } else {
                                        sourceColumn source = new sourceColumn();
                                        source.setId(String.valueOf(sourceColumn.getId()));
                                        source.setColumn(sourceColumn.getName());
                                        source.setStruct(sourceColumn.isStruct());
                                        source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                        source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                        if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                source.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                + convertCoordinate(sourceColumn.getEndPosition()));
                                        }
                                        if (relation.getRelationshipType() == RelationshipType.fdd) {
                                                // Model display-name compares (can be constants/expressions) — see
                                                // the P0d.3c2 reclassification note above.
                                                if (!targetLink.matchesColumn(sourceColumn)) {
                                                        if (!sourceColumn.isStarColumn()) {
                                                                // Record-fill (#695): keep a producer only when it
                                                                // is OPAQUE — a single-column result (function
                                                                // value, collection element) genuinely feeds every
                                                                // field. A source from a multi-column result shape
                                                                // pairs its own fields by name; fanning it onto
                                                                // fields of OTHER shapes asserts dependencies the
                                                                // SQL never made.
                                                                if (!recordFillTarget) {
                                                                        continue;
                                                                }
                                                                boolean opaqueProducer = sourceColumn.getResultSet() == null
                                                                                || sourceColumn.getResultSet().getColumns() == null
                                                                                || sourceColumn.getResultSet().getColumns().size() <= 1;
                                                                if (!opaqueProducer) {
                                                                        continue;
                                                                }
                                                        }
                                                        else {
                                                                boolean flag = false;
                                                                for (ResultColumn candidate : getResultSetColumnLookup(sourceColumn.getResultSet().getColumns()).values()) {
                                                                        if (targetLink.matchesColumn(candidate)) {
                                                                                flag = true;
                                                                                break;
                                                                        }
                                                                }
                                                                if(flag) {
                                                                        continue;
                                                                }
                                                        }
                                                }
                                        }
                                        if (sourceItem.getTransforms() != null) {
                                                for (Transform transform : sourceItem.getTransforms()) {
                                                        source.addTransform(transform);
                                                }
                                        }
                                        relationElement.addSource(source);
                                }
                        } else if (sourceElement instanceof TableColumn) {
                                TableColumn sourceColumn = (TableColumn) sourceElement;
                                if (!sourceColumn.isPseduo() && sourceColumn.hasStarLinkColumn()) {
                                        List<String> linkColumnNames = sourceColumn.getStarLinkColumnNames();
                                        int linkColumnNameSize = linkColumnNames.size();
                                        for (int k = 0; k < linkColumnNameSize; k++) {
                                                String sourceName = linkColumnNames.get(k);
                                                if (relation.getRelationshipType() == RelationshipType.fdd) {
                                                        if (!targetLink.matches(sourceColumn, k))
                                                                continue;
                                                }

                                                TableColumn tableColumn = getTableColumnLookup(sourceColumn.getTable().getColumns()).get(sourceColumn, k);

                                                sourceColumn source = new sourceColumn();
                                                if (tableColumn == null) {
                                                        source.setId(sourceColumn.getId() + "_" + k);
                                                } else {
                                                        source.setId(String.valueOf(tableColumn.getId()));
                                                }
                                                source.setColumn(sourceName);
                                                source.setStruct(sourceColumn.isStruct());
                                                if (containStarColumn(sourceElements, sourceColumn, k)) {
                                                        continue;
                                                }
                                                // Cross-relationship check: skip if explicit source was found in prior relationship
                                                if (targetExplicitNames != null && targetExplicitNames.contains(sourceColumn, k)) {
                                                        continue;
                                                }
                                                if (sourceColumn.getTable().getColumns().size() > 1) {
                                                        for (int y = 0; y < sourceColumn.getTable().getColumns().size(); y++) {
                                                                if (SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn,
                                                                                sourceColumn.getTable().getColumns().get(y).getName(),
                                                                                rawColumnSpelling(sourceColumn.getStarLinkColumnName(k)))) {
                                                                        source.setId(String.valueOf(sourceColumn.getTable().getColumns().get(y).getId()));
                                                                        break;
                                                                }
                                                        }
                                                }
                                                source.setParent_id(String.valueOf(sourceColumn.getTable().getId()));
                                                source.setParent_name(getTableName(sourceColumn.getTable()));
                                                if (sourceItem instanceof TableColumnRelationshipElement) {
                                                        source.setParent_alias(
                                                                        ((TableColumnRelationshipElement) sourceItem).getTableAlias());
                                                }
                                                if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                        + convertCoordinate(sourceColumn.getEndPosition()));
                                                }
                                                if (sourceItem.getTransforms() != null) {
                                                        for (Transform transform : sourceItem.getTransforms()) {
                                                                source.addTransform(transform);
                                                        }
                                                }
                                                relationElement.addSource(source);
                                        }
                                } else {
                                        sourceColumn source = new sourceColumn();
                                        source.setId(String.valueOf(sourceColumn.getId()));
                                        source.setColumn(sourceColumn.getName());
                                        source.setStruct(sourceColumn.isStruct());
                                        source.setParent_id(String.valueOf(sourceColumn.getTable().getId()));
                                        source.setParent_name(getTableName(sourceColumn.getTable()));
                                        if (sourceItem instanceof TableColumnRelationshipElement) {
                                                source.setParent_alias(((TableColumnRelationshipElement) sourceItem).getTableAlias());
                                        }
                                        if (sourceColumn.getStartPosition() != null && sourceColumn.getEndPosition() != null) {
                                                source.setCoordinate(convertCoordinate(sourceColumn.getStartPosition()) + ","
                                                                + convertCoordinate(sourceColumn.getEndPosition()));
                                        }
                                        if (relation.getRelationshipType() == RelationshipType.fdd) {
                                                // Model display-name compare — see the P0d.3c2 reclassification note.
                                                if (!targetLink.matchesColumn(sourceColumn)
                                                                && !sourceColumn.isStarColumn()) {
                                                        // Record-fill (#695): same keep-only-if-opaque rule as
                                                        // the resultset-source branch above.
                                                        if (!recordFillTarget) {
                                                                continue;
                                                        }
                                                        boolean opaqueProducer = sourceColumn.getTable() == null
                                                                        || sourceColumn.getTable().getColumns() == null
                                                                        || sourceColumn.getTable().getColumns().size() <= 1;
                                                        if (!opaqueProducer) {
                                                                continue;
                                                        }
                                                }
                                        }
                                        if (sourceItem.getTransforms() != null) {
                                                for (Transform transform : sourceItem.getTransforms()) {
                                                        source.addTransform(transform);
                                                }
                                        }
                                        relationElement.addSource(source);
                                }
                        }
                }

                if (relationElement.getTarget() != null && relationElement.getSources() != null
                                && !relationElement.getSources().isEmpty()) {
                        dataflow.getRelationships().add(relationElement);
                }
        }

        /**
         * The star links that share {@code targetName}'s legacy normal name, compared without case as
         * the legacy fold made them: the links a name met before normal names were collision-free.
         * Empty when the analysis has no contested names, since every link then already carries it.
         */
        private List<String> legacyStarLinks(List<String> links, String targetName) {
                ModelBindingManager manager = ModelBindingManager.get();
                if (manager == null || !manager.hasContestedNormalNames() || targetName == null || links == null) {
                        return Collections.emptyList();
                }
                String target = legacyColumnKey(targetName);
                if (target == null) {
                        return Collections.emptyList();
                }
                List<String> matched = new ArrayList<String>();
                for (String link : links) {
                        if (target.equals(legacyColumnKey(link))) {
                                matched.add(link);
                        }
                }
                return matched;
        }

        /** Set when the analysis's only unit is scanned from its parse's tokens; see analyzeSqlScript. */
        private boolean collisionScanPending;

        /** The rules names are told apart under: the analysis's own, for the analysis's vendor. */
        private IdentifierService collisionService() {
                IdentifierService service = ModelBindingManager.getGlobalIdentifierService();
                return service != null && service.getProfile().getVendor() == option.getVendor() ? service
                                : IdentifierService.defaultServiceFor(option.getVendor());
        }

        private void publishContestedNormalNames(Set<String> contested) {
                modelManager.setContestedNormalNames(option.getVendor(), contested);
        }

        /** A legacy normal name without case: the equality the star matching used before (HEAD's equalsIgnoreCase). */
        private String legacyColumnKey(String name) {
                String legacy = SQLUtil.legacyNormalSegment(option.getVendor(), ESQLDataObjectType.dotColumn, name);
                return legacy == null ? null : legacy.toUpperCase(Locale.ROOT);
        }

        /**
         * Whether a reference is the wildcard. The parse says so ({@link DlineageUtil#isWildcard}); a
         * synthesized reference spelled {@code *} counts too, while a delimited {@code "*"} is a column.
         */
        private static boolean isWildcardReference(TObjectName column) {
                return DlineageUtil.isStarName(column);
        }

        /** Identifier comparison must use the AST spelling, not a display-normalized name. */
        private String rawColumnSpelling(TObjectName column) {
                if (column == null) return null;
                String name = column.getColumnNameOnly();
                return name == null || name.trim().isEmpty() ? column.toString().trim() : name.trim();
        }

        /**
         * The label a column reference is published under (output version 1): the endpoint labels of star links and the
         * display a star-link lookup falls back to ({@link Column#starLinkIndexOf(Column, String)}). Never a key.
         */
        private String getColumnName(TObjectName column) {
                return LegacyDlineageWireNamesV1.columnName(column);
        }

        /**
         * The struct field path a column reference reads, {@code customer.address.city}, as the one entry
         * {@link TObjectName#getFieldPathRead()} finds it (STRUCT tree plan, section 4). Null when the reference reads a
         * whole column, and in a dialect without STRUCT field reads.
         */
        private String getStructFieldFullName(TObjectName column) {
                if (column == null || !(nestedProfile().buildsDeclaredTree()
                                || (nestedProfile().publishesPropertyNames() && nestedProfile().readsAttributePaths()))) return null;
                gudusoft.gsqlparser.common.structured.StructuredColumnPath read = column.getFieldPathRead();
                return read == null ? null : read.toDisplayString();
        }

        /**
         * The column whose field a column reference reads, {@code customer} in {@code customer.address.city}, as
         * {@link TObjectName#getFieldPathBaseToken()} finds it. Null when the reference reads a whole column.
         */
        private String getStructFieldBaseName(TObjectName column) {
                TSourceToken base = column == null ? null : column.getFieldPathBaseToken();
                return base == null ? null : base.toString();
        }

        /** Whether the dialect reads STRUCT fields by path: BigQuery, the Trino family and Redshift ({@code SUPER}). */
        /** The nested-access profile of the analysis's vendor: every vendor axis of nested access is read from it. */
        private gudusoft.gsqlparser.nodes.structured.NestedAccessProfile nestedProfile() {
                return gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(option.getVendor());
        }

        private String getColumnNameOnly(String column) {
                if (column == null) {
                        return null;
                }
                return DlineageUtil.getColumnNameOnly(column);
        }

        private void appendRecordSetRelation(dataflow dataflow, Relationship[] relations) {
                for (int i = 0; i < relations.length; i++) {
                        AbstractRelationship relation = (AbstractRelationship) relations[i];
                        relationship relationElement = new relationship();
                        relationElement.setType(relation.getRelationshipType().name());
                        if (relation.getFunction() != null) {
                                relationElement.setFunction(relation.getFunction());
                        }
                        if (relation.getEffectType() != null) {
                                relationElement.setEffectType(relation.getEffectType().name());
                        }
                        relationElement.setSqlHash(relation.getSqlHash());
                        relationElement.setSqlComment(relation.getSqlComment());

                        if (relation.getProcedureId() != null) {
                                relationElement.setProcedureId(String.valueOf(relation.getProcedureId()));
                        }
                        relationElement.setId(String.valueOf(relation.getId()));

                        if (relation instanceof RecordSetRelationship) {
                                RecordSetRelationship recordCountRelation = (RecordSetRelationship) relation;

                                Object targetElement = recordCountRelation.getTarget().getElement();
                                if (targetElement instanceof ResultColumn) {
                                        ResultColumn targetColumn = (ResultColumn) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setId(String.valueOf(targetColumn.getId()));
                                        target.setColumn(targetColumn.getName());
                                        target.setStruct(targetColumn.isStruct());
                                        target.setFunction(recordCountRelation.getAggregateFunction());
                                        target.setParent_id(String.valueOf(targetColumn.getResultSet().getId()));
                                        target.setParent_name(getResultSetName(targetColumn.getResultSet()));
                                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                                + convertCoordinate(targetColumn.getEndPosition()));
                                        }
                                        relationElement.setTarget(target);
                                } else if (targetElement instanceof TableColumn) {
                                        TableColumn targetColumn = (TableColumn) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setId(String.valueOf(targetColumn.getId()));
                                        target.setColumn(targetColumn.getName());
                                        target.setStruct(targetColumn.isStruct());
                                        target.setFunction(recordCountRelation.getAggregateFunction());
                                        target.setParent_id(String.valueOf(targetColumn.getTable().getId()));
                                        target.setParent_name(getTableName(targetColumn.getTable()));
                                        if (recordCountRelation.getTarget() instanceof TableColumnRelationshipElement) {
                                                target.setParent_alias(
                                                                ((TableColumnRelationshipElement) recordCountRelation.getTarget()).getTableAlias());
                                        }
                                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                                + convertCoordinate(targetColumn.getEndPosition()));
                                        }
                                        relationElement.setTarget(target);
                                } else if (targetElement instanceof ResultSetRelationRows) {
                                        ResultSetRelationRows targetColumn = (ResultSetRelationRows) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setId(String.valueOf(targetColumn.getId()));
                                        target.setColumn(targetColumn.getName());
                                        target.setParent_id(String.valueOf(targetColumn.getHolder().getId()));
                                        target.setParent_name(getResultSetName(targetColumn.getHolder()));
                                        if (targetColumn.getStartPosition() != null && targetColumn.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(targetColumn.getStartPosition()) + ","
                                                                + convertCoordinate(targetColumn.getEndPosition()));
                                        }
                                        target.setSource("system");
                                        relationElement.setTarget(target);
                                } else {
                                        continue;
                                }

                                Collection<RelationshipElement<?>> sourceElements = (Collection<RelationshipElement<?>>)recordCountRelation.getSources();
                                if (sourceElements.size() == 0) {
                                        continue;
                                }

                                boolean append = false;
                                for (RelationshipElement<?> sourceItem: sourceElements) {
                                        Object sourceElement = sourceItem.getElement();
                                        if (sourceElement instanceof Table) {
                                                Table table = (Table) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setSource_id(String.valueOf(table.getId()));
                                                source.setSource_name(getTableName(table));
                                                if (table.getStartPosition() != null && table.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(table.getStartPosition()) + ","
                                                                        + convertCoordinate(table.getEndPosition()));
                                                }
                                                append = true;
                                                relationElement.addSource(source);
                                        } else if (sourceElement instanceof QueryTable) {
                                                QueryTable table = (QueryTable) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setSource_id(String.valueOf(table.getId()));
                                                source.setSource_name(getResultSetName(table));
                                                if (table.getStartPosition() != null && table.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(table.getStartPosition()) + ","
                                                                        + convertCoordinate(table.getEndPosition()));
                                                }
                                                append = true;
                                                relationElement.addSource(source);
                                        } else if (sourceElement instanceof TableRelationRows) {
                                                TableRelationRows relationRows = (TableRelationRows) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setId(String.valueOf(relationRows.getId()));
                                                source.setColumn(relationRows.getName());
                                                source.setParent_id(String.valueOf(relationRows.getHolder().getId()));
                                                source.setParent_name(getTableName(relationRows.getHolder()));
                                                if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                                        + convertCoordinate(relationRows.getEndPosition()));
                                                }
                                                source.setSource("system");
                                                append = true;
                                                relationElement.addSource(source);
                                        } else if (sourceElement instanceof ResultSetRelationRows) {
                                                ResultSetRelationRows relationRows = (ResultSetRelationRows) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setId(String.valueOf(relationRows.getId()));
                                                source.setColumn(relationRows.getName());
                                                source.setParent_id(String.valueOf(relationRows.getHolder().getId()));
                                                source.setParent_name(getResultSetName(relationRows.getHolder()));
                                                if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                                        + convertCoordinate(relationRows.getEndPosition()));
                                                }
                                                source.setSource("system");
                                                append = true;
                                                relationElement.addSource(source);
                                        } else if (sourceElement instanceof TableColumn) {
                                                TableColumn sourceColumn = (TableColumn) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setId(String.valueOf(sourceColumn.getId()));
                                                source.setColumn(sourceColumn.getName());
                                                source.setStruct(sourceColumn.isStruct());
                                                source.setParent_id(String.valueOf(sourceColumn.getTable().getId()));
                                                source.setParent_name(getTableName(sourceColumn.getTable()));
                                                if (sourceItem instanceof TableColumnRelationshipElement) {
                                                        source.setParent_alias(
                                                                        ((TableColumnRelationshipElement) sourceItem).getTableAlias());
                                                }
                                                setSourceCoordinate(source, sourceItem, sourceColumn);
                                                append = true;
                                                relationElement.addSource(source);
                                        }
                                        if (sourceElement instanceof ResultColumn) {
                                                ResultColumn sourceColumn = (ResultColumn) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setId(String.valueOf(sourceColumn.getId()));
                                                source.setColumn(sourceColumn.getName());
                                                source.setStruct(sourceColumn.isStruct());
                                                source.setParent_id(String.valueOf(sourceColumn.getResultSet().getId()));
                                                source.setParent_name(getResultSetName(sourceColumn.getResultSet()));
                                                setSourceCoordinate(source, sourceItem, sourceColumn);
                                                append = true;
                                                relationElement.addSource(source);
                                        }
                                }

                                if (append)
                                        dataflow.getRelationships().add(relationElement);
                        }
                }
        }

        private void appendCallRelation(dataflow dataflow, Relationship[] relations) {
                for (int i = 0; i < relations.length; i++) {
                        AbstractRelationship relation = (AbstractRelationship) relations[i];
                        relationship relationElement = new relationship();
                        relationElement.setType(relation.getRelationshipType().name());
                        if (relation.getFunction() != null) {
                                relationElement.setFunction(relation.getFunction());
                        }
                        if (relation.getEffectType() != null) {
                                relationElement.setEffectType(relation.getEffectType().name());
                        }
                        relationElement.setSqlHash(relation.getSqlHash());
                        relationElement.setSqlComment(relation.getSqlComment());
                        
                        if (relation.getProcedureId() != null) {
                                relationElement.setProcedureId(String.valueOf(relation.getProcedureId()));
                        }
                        relationElement.setId(String.valueOf(relation.getId()));

                        if (relation instanceof CallRelationship) {
                                CallRelationship callRelation = (CallRelationship) relation;
                                
                                if (callRelation.getCallObject() != null) {
                                        relationElement.setCallStmt(callRelation.getCallObject().toString());
                                        if (callRelation.getStartPosition() != null && callRelation.getEndPosition() != null) {
                                                relationElement.setCallCoordinate(convertCoordinate(callRelation.getStartPosition()) + ","
                                                                + convertCoordinate(callRelation.getEndPosition()));
                                        }
                                }
                                
                                if (Boolean.TRUE.equals(callRelation.getBuiltIn())) {
                                        relationElement.setBuiltIn(true);
                                }
                                Object targetElement = callRelation.getTarget().getElement();
                                if (targetElement instanceof Procedure) {
                                        Procedure procedure = (Procedure) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setId(String.valueOf(procedure.getId()));
                                        target.setName(getProcedureName(procedure));
                                        if (procedure.getStartPosition() != null && procedure.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(procedure.getStartPosition()) + ","
                                                                + convertCoordinate(procedure.getEndPosition()));
                                        }
                                        String clazz = procedure.getProcedureObject().getClass().getSimpleName().toLowerCase(Locale.ROOT);
                                        if (clazz.indexOf("function") != -1) {
                                                target.setType("function");
                                        } else if (clazz.indexOf("trigger") != -1) {
                                                target.setType("trigger");
                                        } else if (clazz.indexOf("macro") != -1) {
                                                target.setType("macro");
                                        } else {
                                                target.setType("procedure");
                                        }
                                        relationElement.setCaller(target);
                                } else if (targetElement instanceof Process) {
                                        Process process = (Process) targetElement;
                                        targetColumn target = new targetColumn();
                                        target.setId(String.valueOf(process.getId()));
                                        target.setName(getProcessName(process));
                                        target.setType("process");
                                        if (process.getStartPosition() != null && process.getEndPosition() != null) {
                                                target.setCoordinate(convertCoordinate(process.getStartPosition()) + ","
                                                                + convertCoordinate(process.getEndPosition()));
                                        }
                                        relationElement.setCaller(target);
                                } else {
                                        continue;
                                }

                                Collection<RelationshipElement<?>> sourceElements = (Collection<RelationshipElement<?>>)callRelation.getSources();
                                if (sourceElements.size() == 0) {
                                        continue;
                                }

                                boolean append = false;
                                for (RelationshipElement<?> sourceItem: sourceElements) {
                                        Object sourceElement = sourceItem.getElement();
                                        if (sourceElement instanceof Procedure) {
                                                Procedure procedure = (Procedure) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setId(String.valueOf(procedure.getId()));
                                                source.setName(getProcedureName(procedure));
                                                if (procedure.getStartPosition() != null && procedure.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(procedure.getStartPosition()) + ","
                                                                        + convertCoordinate(procedure.getEndPosition()));
                                                }
                                                String clazz = procedure.getProcedureObject().getClass().getSimpleName().toLowerCase(Locale.ROOT);
                                                if (clazz.indexOf("function") != -1) {
                                                        source.setType("function");
                                                } else if (clazz.indexOf("trigger") != -1) {
                                                        source.setType("trigger");
                                                } else if (clazz.indexOf("macro") != -1) {
                                                        source.setType("macro");
                                                } else {
                                                        source.setType("procedure");
                                                }
                                                append = true;
                                                relationElement.getCallees().add(source);
                                        } else if (sourceElement instanceof Function) {
                                                Function function = (Function) sourceElement;
                                                sourceColumn source = new sourceColumn();
                                                source.setId(String.valueOf(function.getId()));
                                                source.setName(function.getFunctionObject() instanceof TObjectName
                                                                ? function.getFunctionName() : getFunctionName(function.getFunctionObject()));
                                                if (function.getStartPosition() != null && function.getEndPosition() != null) {
                                                        source.setCoordinate(convertCoordinate(function.getStartPosition()) + ","
                                                                        + convertCoordinate(function.getEndPosition()));
                                                }
                                                source.setType("function");
                                                append = true;
                                                relationElement.getCallees().add(source);
                                        }
                                }

                                if (append)
                                        dataflow.getRelationships().add(relationElement);
                        }
                }
        }

        private void appendResultSets(dataflow dataflow) {
                Set<ResultSet> resultSets = modelManager.getResultSets(); 
                for (ResultSet resultSet: resultSets) {
                        appendResultSet(dataflow, resultSet);
                }
        }

        private void appendResultSet(dataflow dataflow, ResultSet resultSetModel) {
                if (!appendResultSets.contains(resultSetModel)) {
                        appendResultSets.add(resultSetModel);
                } else {
                        return;
                }

                table resultSetElement = new table();
                resultSetElement.setId(String.valueOf(resultSetModel.getId()));
                resultSetElement.setServer(resultSetModel.getServer());
                if (!SQLUtil.isEmpty(resultSetModel.getDatabase())) {
                        resultSetElement.setDatabase(resultSetModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(resultSetModel.getSchema())) {
                        resultSetElement.setSchema(resultSetModel.getSchema());
                }
                resultSetElement.setName(getResultSetName(resultSetModel));
                resultSetElement.setType(getResultSetType(resultSetModel));
                if (resultSetElement.isFunction()) {
                        // the routine a call names, from its name as written, before normalized output renames it
                        resultSetElement.setRoutineKey(DataflowUtility.calledRoutineKey(resultSetElement.getName()));
                }
                // if ((ignoreRecordSet || simpleOutput) && resultSetModel.isTarget()) {
                resultSetElement.setIsTarget(String.valueOf(resultSetModel.isTarget()));
                // }
                resultSetElement.setIsDetermined(String.valueOf(resultSetModel.isDetermined()));
                if (resultSetModel.getProcedureId() != null) {
                        resultSetElement.setProcedureId(resultSetModel.getProcedureId());
                }
                if (resultSetModel.getStartPosition() != null && resultSetModel.getEndPosition() != null) {
                        resultSetElement.setCoordinate(convertCoordinate(resultSetModel.getStartPosition()) + ","
                                        + convertCoordinate(resultSetModel.getEndPosition()));
                }
                dataflow.getResultsets().add(resultSetElement);

                // each column followed by the STRUCT field nodes below it (Mantis 4836)
                List<ResultColumn> columns = resultSetModel.getColumnsWithFieldPaths();

                // Columns that publish the same name are qualified by their table.
                Map<Object, Integer> publishedCounts = new HashMap<Object, Integer>();
                for (ResultColumn column : columns) {
                        Object publishedKey = publishedColumnKey(column);
                        publishedCounts.put(publishedKey, publishedCounts.containsKey(publishedKey) ? publishedCounts.get(publishedKey) + 1 : 1);
                        // if (column.hasStarLinkColumn()) {
                        // List<String> starLinkColumns = column.getStarLinkColumnNames();
                        // for (int k = 0; k < starLinkColumns.size(); k++) {
                        // columnName = starLinkColumns.get(k);
                        // if (!columnCounts.containsKey(columnName)) {
                        // columnCounts.put(columnName, 0);
                        // }
                        // columnCounts.put(columnName, columnCounts.get(columnName) + 1);
                        // }
                        // }
                }

                for (int j = 0; j < columns.size(); j++) {
                        ResultColumn columnModel = columns.get(j);
                        if (columnModel.hasStarLinkColumn()) {
                                // List<String> starLinkColumns =
                                // columnModel.getStarLinkColumnNames();
                                // for (int k = 0; k < starLinkColumns.size(); k++) {
                                // column columnElement = new column();
                                // columnElement.setId( String.valueOf(columnModel.getId()) +
                                // "_" + k);
                                // String columnName = starLinkColumns.get(k);
                                // columnElement.setName(columnName);
                                // if(columnModel.isFunction()){
                                // columnElement.setIsFunction(String.valueOf(columnModel.isFunction()));
                                // }
                                // if (columnModel.getStartPosition() != null &&
                                // columnModel.getEndPosition() != null) {
                                // columnElement.setCoordinate(
                                // columnModel.getStartPosition() + "," +
                                // columnModel.getEndPosition());
                                // }
                                // String identifier = columnName;
                                // if(columnCounts.containsKey(identifier) &&
                                // columnCounts.get(identifier)>1){
                                // TObjectName column =
                                // columnModel.getStarLinkColumns().get(columnName).iterator().next();
                                // if(!SQLUtil.isEmpty(getQualifiedTable(column))){
                                // columnElement.setQualifiedTable(getQualifiedTable(column));
                                // }
                                // }
                                // resultSetElement.getColumns().add(columnElement);
                                // }
                                if (columnModel.isShowStar()) {
                                        column columnElement = new column();
                                        columnElement.setId(String.valueOf(columnModel.getId()));
                                        columnElement.setName(columnModel.getName());
                                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                                        columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                                        if (columnModel.isFunction()) {
                                                columnElement.setIsFunction(String.valueOf(columnModel.isFunction()));
                                        }
                                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                                + convertCoordinate(columnModel.getEndPosition()));
                                        }

                                        if (publishedCounts.get(publishedColumnKey(columnModel)) > 1) {
                                                String qualifiedTable = getQualifiedTable(columnModel);
                                                if (!SQLUtil.isEmpty(qualifiedTable)) {
                                                        columnElement.setQualifiedTable(qualifiedTable);
                                                }
                                        }
                                        resultSetElement.getColumns().add(columnElement);
                                }
                        } else {
                                column columnElement = new column();
                                columnElement.setId(String.valueOf(columnModel.getId()));
                                columnElement.setName(columnModel.getName());
                                DlineageUtil.publishStarProvenance(columnElement, columnModel);
                                columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                                if (columnModel.isFunction()) {
                                        columnElement.setIsFunction(String.valueOf(columnModel.isFunction()));
                                }
                                if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                        + convertCoordinate(columnModel.getEndPosition()));
                                }

                                if (publishedCounts.get(publishedColumnKey(columnModel)) > 1) {
                                        String qualifiedTable = getQualifiedTable(columnModel);
                                        if (!SQLUtil.isEmpty(qualifiedTable)) {
                                                columnElement.setQualifiedTable(qualifiedTable);
                                        }
                                }
                                resultSetElement.getColumns().add(columnElement);
                        }
                }

                ResultSetRelationRows relationRows = resultSetModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        resultSetElement.getColumns().add(relationRowsElement);
                }
        }

        private String getQualifiedTable(ResultColumn columnModel) {
                if (columnModel.getColumnObject() instanceof TObjectName) {
                        return getQualifiedTable((TObjectName) columnModel.getColumnObject());
                }
                if (columnModel.getColumnObject() instanceof TResultColumn) {
                        TObjectName field = ((TResultColumn) columnModel.getColumnObject()).getFieldAttr();
                        if (field != null) {
                                return getQualifiedTable(field);
                        }
                }
                return null;
        }

        private String getQualifiedTable(TObjectName column) {
                if (column == null)
                        return null;
                String[] splits = column.toString().split("\\.");
                if (splits.length > 1) {
                        return splits[splits.length - 2];
                }
                return null;
        }

        /**
         * Get the qualified prefix (schema.table) from a column name for 3-part names.
         * For example, for "sch.pk_constv2.c_cdsl", returns "sch.pk_constv2".
         * Returns null if the column doesn't have both schema and table parts.
         */
        private String getQualifiedPrefixFromColumn(TObjectName column) {
                if (column == null) return null;

                // STRUCT tree: customer.address.city read as a field path, or that several relations could own (rule R3), is a
                // field read, not a column of a schema customer with a table address
                if (nestedProfile().buildsDeclaredTree()
                                && (isUndecidedFieldRead(column) || column.getFieldPathRead() != null)) {
                        return null;
                }

                // Check if both schema and table tokens are present (3-part name)
                String schemaStr = column.getSchemaString();
                String tableStr = column.getTableString();

                if (schemaStr != null && !schemaStr.isEmpty() &&
                        tableStr != null && !tableStr.isEmpty()) {
                        return schemaStr + "." + tableStr;
                }

                // A field path has no qualifier to split off its text: the parts of payload.address.city before its last one
                // are a column and a field, not a schema payload with a table address (Mantis 4822, STRUCT tree plan).
                if (DlineageUtil.isFieldPath(column) && nestedProfile().buildsDeclaredTree()) {
                        return null;
                }

                // Fallback: parse from toString() for complex cases
                String[] splits = column.toString().split("\\.");
                if (splits.length >= 3) {
                        // Return all parts except the last one (column name)
                        StringBuilder prefix = new StringBuilder();
                        for (int i = 0; i < splits.length - 1; i++) {
                                if (i > 0) prefix.append(".");
                                prefix.append(splits[i]);
                        }
                        return prefix.toString();
                }

                return null;
        }

        private String getResultSetType(ResultSet resultSetModel) {
                if (resultSetModel instanceof QueryTable) {
                        QueryTable table = (QueryTable) resultSetModel;
                        if (table.getTableObject().getCTE() != null) {
                                return "with_cte";
                        }
                }

                if (resultSetModel instanceof SelectSetResultSet) {
                        ESetOperatorType type = ((SelectSetResultSet) resultSetModel).getSetOperatorType();
                        return "select_" + type.name();
                }

                if (resultSetModel instanceof SelectResultSet) {
                        if (((SelectResultSet) resultSetModel).getSelectStmt().getParentStmt() instanceof TInsertSqlStatement) {
                                return "insert-select";
                        }
                        if (((SelectResultSet) resultSetModel).getSelectStmt().getParentStmt() instanceof TUpdateSqlStatement) {
                                return "update-select";
                        }
                }

                if (resultSetModel.getGspObject() instanceof TMergeUpdateClause) {
                        return "merge-update";
                }

                if (resultSetModel.getGspObject() instanceof TOutputClause) {
                        return ResultSetType.output.name();
                }

                if (resultSetModel.getGspObject() instanceof TMergeInsertClause) {
                        return "merge-insert";
                }

                if (resultSetModel.getGspObject() instanceof TUpdateSqlStatement) {
                        return "update-set";
                }

                if (resultSetModel.getGspObject() instanceof TFunctionCall && ((TFunctionCall)resultSetModel.getGspObject()).getFunctionType() == EFunctionType.array_t) {
                        return ResultSetType.array.name();
                }

                if (resultSetModel.getGspObject() instanceof TFunctionCall && ((TFunctionCall)resultSetModel.getGspObject()).getFunctionType() == EFunctionType.struct_t) {
                        return ResultSetType.struct.name();
                }

                if (resultSetModel.getGspObject() instanceof TFunctionCall || resultSetModel instanceof Function) {
                        return ResultSetType.function.name();
                }

                if (resultSetModel.getGspObject() instanceof TAliasClause) {
                        return ResultSetType.alias.name();
                }

                if (resultSetModel.getGspObject() instanceof TCursorDeclStmt) {
                        return ResultSetType.cursor.name();
                }

                if (resultSetModel instanceof PivotedTable) {
                        if (((PivotedTable) resultSetModel).isUnpivoted()) {
                                return ResultSetType.unpivot_table.name();
                        }
                        return ResultSetType.pivot_table.name();
                }

                return "select_list";
        }

        private String getTableName(Table tableModel) {
                if (modelManager.DISPLAY_NAME.containsKey(tableModel.getId())) {
                        return modelManager.DISPLAY_NAME.get(tableModel.getId());
                }

                String tableName;
                if (tableModel.getFullName() != null && tableModel.getFullName().trim().length() > 0) {
                        return tableModel.getFullName();
                }
                if (tableModel.getAlias() != null && tableModel.getAlias().trim().length() > 0) {
                        tableName = getResultSetWithId("RESULT_OF_" + tableModel.getAlias());

                } else {
                        tableName = getResultSetDisplayId("RS");
                }
                modelManager.DISPLAY_NAME.put(tableModel.getId(), tableName);
                return tableName;
        }

        private String getProcedureName(Procedure procedureModel) {
                if (modelManager.DISPLAY_NAME.containsKey(procedureModel.getId())) {
                        return modelManager.DISPLAY_NAME.get(procedureModel.getId());
                }

                String procedureName = procedureModel.getFullName();

                modelManager.DISPLAY_NAME.put(procedureModel.getId(), procedureName);
                return procedureName;
        }

        private String getProcessName(Process processModel) {
                if (modelManager.DISPLAY_NAME.containsKey(processModel.getId())) {
                        return modelManager.DISPLAY_NAME.get(processModel.getId());
                } else {
                        if (processModel.getCustomType() != null) {
                                String name = processModel.getCustomType();
                                modelManager.DISPLAY_NAME.put(processModel.getId(), name);
                                return name;
                        }
                        String name = processModel.getType();
                        String procedureName = getProcedureParentName(processModel.getGspObject());
                        if (procedureName != null) {
                                name = getResultSetDisplayId(procedureName + " " + name);
                        } else {
                                name = getResultSetDisplayId("Query " + name);
                        }
                        modelManager.DISPLAY_NAME.put(processModel.getId(), name);
                        return name;
                }
        }

        private String getDisplayIdByType(String type) {
                if (!modelManager.DISPLAY_ID.containsKey(type)) {
                        modelManager.DISPLAY_ID.put(type, option.getStartId() + 1);
                        return type + "-" + (option.getStartId() + 1);
                } else {
                        long id = modelManager.DISPLAY_ID.get(type);
                        modelManager.DISPLAY_ID.put(type, id + 1);
                        return type + "-" + (id + 1);
                }
        }
        
        private String getDisplayIdByTypeFromZero(String type) {
                if (!modelManager.DISPLAY_ID.containsKey(type)) {
                        modelManager.DISPLAY_ID.put(type, option.getStartId());
                        if(option.getStartId() == 0) {
                                return type;
                        }
                        return type + "-" + (option.getStartId() + 1);
                } else {
                        long id = modelManager.DISPLAY_ID.get(type);
                        modelManager.DISPLAY_ID.put(type, id + 1);
                        return type + "-" + (id + 1);
                }
        }

        private String getConstantName(Table tableModel) {
                if (modelManager.DISPLAY_NAME.containsKey(tableModel.getId())) {
                        return modelManager.DISPLAY_NAME.get(tableModel.getId());
                } else {
                        String name = getDisplayIdByType("SQL_CONSTANTS");
                        modelManager.DISPLAY_NAME.put(tableModel.getId(), name);
                        return name;
                }
        }
        
        private String getTempTableName(TTable table) {
                if (modelManager.DISPLAY_NAME.containsKey((long)System.identityHashCode(table))) {
                        return modelManager.DISPLAY_NAME.get((long)System.identityHashCode(table));
                } else {
                        String name = getDisplayIdByTypeFromZero(table.getName());
                        modelManager.DISPLAY_NAME.put((long)System.identityHashCode(table), name);
                        return name;
                }
        }

        private String getResultSetName(ResultSet resultSetModel) {

                if (modelManager.DISPLAY_NAME.containsKey(resultSetModel.getId())) {
                        return modelManager.DISPLAY_NAME.get(resultSetModel.getId());
                }
                
                if (resultSetModel.getGspObject() instanceof TFunctionCall && ((TFunctionCall)resultSetModel.getGspObject()).getFunctionType() == EFunctionType.array_t) {
                        String name = getResultSetDisplayId("ARRAY");
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        if(option.containsResultSetType(ResultSetType.array)) {
                                resultSetModel.setTarget(true);
                        }
                        return name;
                }
                
                if (resultSetModel.getGspObject() instanceof TFunctionCall && ((TFunctionCall)resultSetModel.getGspObject()).getFunctionType() == EFunctionType.struct_t) {
                        String name = getResultSetDisplayId("STRUCT");
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        if(option.containsResultSetType(ResultSetType.struct)) {
                                resultSetModel.setTarget(true);
                        }
                        return name;
                }

                if (resultSetModel instanceof QueryTable) {
                        QueryTable table = (QueryTable) resultSetModel;
                        if (table.getAlias() != null && table.getAlias().trim().length() > 0) {
                                String name = getResultSetWithId("RESULT_OF_" + table.getAlias().trim());
                                if (table.getTableObject().getCTE() != null) {
                                        name = getResultSetWithId("RESULT_OF_" + table.getTableObject().getCTE().getTableName().toString()
                                                        + "_" + table.getAlias().trim());
                                }
                                modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                                if(option.containsResultSetType(ResultSetType.result_of)) {
                                        resultSetModel.setTarget(true);
                                }
                                return name;
                        } else if (table.getTableObject().getCTE() != null) {
                                String name = getResultSetWithId("CTE-" + table.getTableObject().getCTE().getTableName().toString());
                                modelManager.DISPLAY_NAME.put(table.getId(), name);
                                if(option.containsResultSetType(ResultSetType.cte)) {
                                        resultSetModel.setTarget(true);
                                }
                                return name;
                        }
                }

                if (resultSetModel instanceof SelectResultSet) {
                        if (((SelectResultSet) resultSetModel).getSelectStmt().getParentStmt() instanceof TInsertSqlStatement) {
                                String name = getResultSetDisplayId("INSERT-SELECT");
                                modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                                if(option.containsResultSetType(ResultSetType.insert_select)) {
                                        resultSetModel.setTarget(true);
                                }
                                return name;
                        }

                        if (((SelectResultSet) resultSetModel).getSelectStmt().getParentStmt() instanceof TUpdateSqlStatement) {
                                String name = getResultSetDisplayId("UPDATE-SELECT");
                                modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                                if(option.containsResultSetType(ResultSetType.update_select)) {
                                        resultSetModel.setTarget(true);
                                }
                                return name;
                        }
                }

                if (resultSetModel instanceof SelectSetResultSet) {
                        ESetOperatorType type = ((SelectSetResultSet) resultSetModel).getSetOperatorType();
                        String name = getResultSetDisplayId("RESULT_OF_" + type.name().toUpperCase(Locale.ROOT));
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        if(option.containsResultSetType(ResultSetType.result_of)) {
                                resultSetModel.setTarget(true);
                        }
                        return name;
                }

                if (resultSetModel.getGspObject() instanceof TMergeUpdateClause) {
                        String name = getResultSetDisplayId("MERGE-UPDATE");
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        if(option.containsResultSetType(ResultSetType.merge_update)) {
                                resultSetModel.setTarget(true);
                        }
                        return name;
                }

                if (resultSetModel.getGspObject() instanceof TOutputClause) {
                        String name = getResultSetDisplayId("OUTPUT");
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        if(option.containsResultSetType(ResultSetType.output)) {
                                resultSetModel.setTarget(true);
                        }
                        return name;
                }

                if (resultSetModel.getGspObject() instanceof TMergeInsertClause) {
                        String name = getResultSetDisplayId("MERGE-INSERT");
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        if(option.containsResultSetType(ResultSetType.merge_insert)) {
                                resultSetModel.setTarget(true);
                        }
                        return name;
                }

                if (resultSetModel.getGspObject() instanceof TUpdateSqlStatement) {
                        String name = getResultSetDisplayId("UPDATE-SET");
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        if(option.containsResultSetType(ResultSetType.update_set)) {
                                resultSetModel.setTarget(true);
                        }
                        return name;
                }

                if (resultSetModel.getGspObject() instanceof TCaseExpression) {
                        String name = ((Function) resultSetModel).getFunctionName();
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        if (option.containsResultSetType(ResultSetType.case_when) || option.containsResultSetType(ResultSetType.function)) {
                                resultSetModel.setTarget(true);
                        }
                        return name;
                }
                
                if (resultSetModel.getGspObject() instanceof TFunctionCall || resultSetModel instanceof Function) {
                        String name = ((Function) resultSetModel).getFunctionName();
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        if(option.containsResultSetType(ResultSetType.function)) {
                                resultSetModel.setTarget(true);
                        }
                        return name;
                }

                if (resultSetModel instanceof PivotedTable) {
                        String name = getResultSetDisplayId("PIVOT-TABLE");
                        if (((PivotedTable) resultSetModel).isUnpivoted()) {
                                name = getResultSetDisplayId("UNPIVOT-TABLE");
                                if(option.containsResultSetType(ResultSetType.unpivot_table)) {
                                        resultSetModel.setTarget(true);
                                }
                        }
                        else {
                                if(option.containsResultSetType(ResultSetType.pivot_table)) {
                                        resultSetModel.setTarget(true);
                                }
                        }
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        return name;
                }

                if (resultSetModel instanceof Alias) {
                        String name = getResultSetDisplayId("ALIAS");
                        modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                        if(option.containsResultSetType(ResultSetType.alias)) {
                                resultSetModel.setTarget(true);
                        }
                        return name;
                }

                String name = getResultSetDisplayId("RS");
                modelManager.DISPLAY_NAME.put(resultSetModel.getId(), name);
                if(option.containsResultSetType(ResultSetType.select_list)) {
                        resultSetModel.setTarget(true);
                }
                return name;
        }

        private String getResultSetWithId(String type) {
                // A display label (RESULT_OF_<alias>, CTE-<name>): its published form counts the ids of one label family.
                type = LegacyDlineageWireNamesV1.tableName(type);
                if (!modelManager.DISPLAY_ID.containsKey(type)) {
                        modelManager.DISPLAY_ID.put(type, option.getStartId() + 1);
                        return type + "-" + (option.getStartId() + 1);
                } else {
                        long id = modelManager.DISPLAY_ID.get(type);
                        modelManager.DISPLAY_ID.put(type, id + 1);
                        return type + "-" + (id + 1);
                }
        }

        private String getResultSetDisplayId(String type) {
                if (!modelManager.DISPLAY_ID.containsKey(type)) {
                        modelManager.DISPLAY_ID.put(type, option.getStartId() + 1);
                        return type + "-" + (option.getStartId() + 1);
                } else {
                        long id = modelManager.DISPLAY_ID.get(type);
                        modelManager.DISPLAY_ID.put(type, id + 1);
                        return type + "-" + (id + 1);
                }
        }

        private void appendViews(dataflow dataflow) {
                List<TCustomSqlStatement> views = modelManager.getViews();
                for (int i = 0; i < views.size(); i++) {
                        Table viewModel = (Table) modelManager.getViewModel(views.get(i));
                        if (!tableIds.contains(viewModel.getId())) {
                                appendViewModel(dataflow, viewModel);
                                tableIds.add(viewModel.getId());
                        }
                }

                List<TTable> tables = modelManager.getBaseTables();
                for (int i = 0; i < tables.size(); i++) {
                        Object model = modelManager.getModel(tables.get(i));
                        if (model instanceof Table) {
                                Table tableModel = (Table) model;
                                if (tableModel.isView()) {
                                        if (!tableIds.contains(tableModel.getId())) {
                                                appendViewModel(dataflow, tableModel);
                                                tableIds.add(tableModel.getId());
                                        }
                                }
                        }
                }

                List<Table> tableNames = modelManager.getTablesByName();
                for (int i = 0; i < tableNames.size(); i++) {
                        Table tableModel = tableNames.get(i);
                        if (tableModel.isView()) {
                                if (!tableIds.contains(tableModel.getId())) {
                                        appendViewModel(dataflow, tableModel);
                                        tableIds.add(tableModel.getId());
                                }
                        }
                }
        }

        private void appendViewModel(dataflow dataflow, Table viewModel) {
                table viewElement = new table();
                viewElement.setId(String.valueOf(viewModel.getId()));
                if (!SQLUtil.isEmpty(viewModel.getDatabase())) {
                        viewElement.setDatabase(viewModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(viewModel.getSchema())) {
                        viewElement.setSchema(viewModel.getSchema());
                }
                viewElement.setServer(viewModel.getServer());
                viewElement.setName(viewModel.getName());
                viewElement.setIdentifierKey(viewModel.getIdentifierKey());
                viewElement.setMergeIdentity(viewModel.getCanonicalIdentity());
                viewElement.setType("view");
                // Propagate the view sub type (e.g. temp_table for CREATE TEMPORARY VIEW)
                // so consumers can tell a temporary view apart from a regular one. Mantis 4538.
                if (viewModel.getSubType() != null) {
                        viewElement.setSubType(viewModel.getSubType().name());
                }
                viewElement.setStarStmt(viewModel.getStarStmt());

                if(viewModel.isFromDDL()){
                        viewElement.setFromDDL(String.valueOf(viewModel.isFromDDL()));
                }

        if(option.isTraceTablePosition()){
            for (Pair<Pair3<Long, Long, String>, Pair3<Long, Long, String>> position:viewModel.getPositions()){
                viewElement.setCoordinate(convertCoordinate(position.first)+","+convertCoordinate(position.second));
            }
        }
        else {
            viewElement.setCoordinate(convertCoordinate(viewModel.getStartPosition()) + ","
                    + convertCoordinate(viewModel.getEndPosition()));
        }

                if (viewModel.getProcesses() != null) {
                        List<String> processIds = new ArrayList<String>();
                        for (Process process : viewModel.getProcesses()) {
                                processIds.add(String.valueOf(process.getId()));
                        }
                        viewElement.setProcessIds(processIds);
                }
                dataflow.getViews().add(viewElement);

                List<TableColumn> columns = viewModel.getColumns();

                if (containStarColumn(columns)) {
                        for (TableColumn column : columns) {
                                if (column.isStarColumn()) {
                                        for (TableColumn starElement : columns) {
                                                if (starElement == column) {
                                                        continue;
                                                }
                                                TObjectName columnObject = starElement.getColumnObject();
                                                column.bindStarLinkColumn(columnObject);
                                        }
                                        if (viewModel.isCreateTable()) {
                                                column.setShowStar(false);
                                        }
                                }
                        }
                }

                // each column followed by the STRUCT field path nodes below it, as for a table (Mantis 4834)
                List<TableColumn> publishedColumns = viewModel.getColumnsWithFieldPaths();
                for (int j = 0; j < publishedColumns.size(); j++) {
                        TableColumn columnModel = (TableColumn) publishedColumns.get(j);
                        if (!columnModel.isPseduo() && columnModel.hasStarLinkColumn()) {
                                List<String> starLinkColumnList = columnModel.getStarLinkColumnNames();
                                for (int k = 0; k < starLinkColumnList.size(); k++) {
                                        column columnElement = new column();
                                        columnElement.setId(String.valueOf(columnModel.getId()) + "_" + k);
                                        columnElement.setIdentifierKey(columnModel.starLinkIdentifier(k));
                                        columnElement.setSqlSpelling(columnModel.starLinkSqlSpelling(k));
                                        String columnName = starLinkColumnList.get(k);
                                        if (containStarColumn(columns, columnModel, k)) {
                                                continue;
                                        }
                                        columnElement.setName(columnName);
                                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                                + convertCoordinate(columnModel.getEndPosition()));
                                        }
                                        viewElement.getColumns().add(columnElement);
                                }

                                if (columnModel.isShowStar()) {
                                        column columnElement = new column();
                                        columnElement.setId(String.valueOf(columnModel.getId()));
                                        columnElement.setName(columnModel.getName());
                                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                                        columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                                        columnElement.setFieldPathKey(fieldPathMergeKey(columnModel));
                                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                                + convertCoordinate(columnModel.getEndPosition()));
                                        }
                                        viewElement.getColumns().add(columnElement);
                                }

                        } else {
                                column columnElement = new column();
                                columnElement.setId(String.valueOf(columnModel.getId()));
                                columnElement.setName(columnModel.getName());
                                DlineageUtil.publishStarProvenance(columnElement, columnModel);
                                columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                                columnElement.setFieldPathKey(fieldPathMergeKey(columnModel));
                                if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                        + convertCoordinate(columnModel.getEndPosition()));
                                }
                                if(columnModel.isPseduo()) {
                                        columnElement.setSource("system");
                                }
                                viewElement.getColumns().add(columnElement);
                        }
                }

                TableRelationRows relationRows = viewModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        viewElement.getColumns().add(relationRowsElement);
                }
        }

        private void appendStreamModel(dataflow dataflow, Table streamModel) {
                table streamElement = new table();
                streamElement.setId(String.valueOf(streamModel.getId()));
                if (!SQLUtil.isEmpty(streamModel.getDatabase())) {
                        streamElement.setDatabase(streamModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(streamModel.getSchema())) {
                        streamElement.setSchema(streamModel.getSchema());
                }
                streamElement.setServer(streamModel.getServer());
                streamElement.setName(streamModel.getName());
                streamElement.setType("stream");
                if (streamModel.getFileType() != null) {
                        streamElement.setFileType(SQLUtil.trimColumnStringQuote(streamModel.getFileType()));
                }

                if (streamModel.getStartPosition() != null && streamModel.getEndPosition() != null) {
                        streamElement.setCoordinate(convertCoordinate(streamModel.getStartPosition()) + ","
                                        + convertCoordinate(streamModel.getEndPosition()));
                }

                if (streamModel.getProcesses() != null) {
                        List<String> processIds = new ArrayList<String>();
                        for (Process process : streamModel.getProcesses()) {
                                processIds.add(String.valueOf(process.getId()));
                        }
                        streamElement.setProcessIds(processIds);
                }
                dataflow.getStreams().add(streamElement);

                List<TableColumn> columns = streamModel.getColumns();

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = (TableColumn) columns.get(j);
                        column columnElement = new column();
                        columnElement.setId(String.valueOf(columnModel.getId()));
                        columnElement.setName(SQLUtil.trimColumnStringQuote(columnModel.getName()));
                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                        + convertCoordinate(columnModel.getEndPosition()));
                        streamElement.getColumns().add(columnElement);
                }

                TableRelationRows relationRows = streamModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        streamElement.getColumns().add(relationRowsElement);
                }
        }

        private void appendStageModel(dataflow dataflow, Table stageModel) {
                table stageElement = new table();
                stageElement.setId(String.valueOf(stageModel.getId()));
                if (!SQLUtil.isEmpty(stageModel.getDatabase())) {
                        stageElement.setDatabase(stageModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(stageModel.getSchema())) {
                        stageElement.setSchema(stageModel.getSchema());
                }
                stageElement.setServer(stageModel.getServer());
                stageElement.setName(stageModel.getName());
                stageElement.setType("stage");
                stageElement.setLocation(stageModel.getLocation());
                if (stageModel.getFileType() != null) {
                        stageElement.setFileType(SQLUtil.trimColumnStringQuote(stageModel.getFileType()));
                }

                if (stageModel.getStartPosition() != null && stageModel.getEndPosition() != null) {
                        stageElement.setCoordinate(convertCoordinate(stageModel.getStartPosition()) + ","
                                        + convertCoordinate(stageModel.getEndPosition()));
                }

                if (stageModel.getProcesses() != null) {
                        List<String> processIds = new ArrayList<String>();
                        for (Process process : stageModel.getProcesses()) {
                                processIds.add(String.valueOf(process.getId()));
                        }
                        stageElement.setProcessIds(processIds);
                }
                dataflow.getStages().add(stageElement);

                List<TableColumn> columns = stageModel.getColumns();

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = (TableColumn) columns.get(j);
                        column columnElement = new column();
                        columnElement.setId(String.valueOf(columnModel.getId()));
                        columnElement.setName(SQLUtil.trimColumnStringQuote(columnModel.getName()));
                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                        + convertCoordinate(columnModel.getEndPosition()));
                        stageElement.getColumns().add(columnElement);
                }

                TableRelationRows relationRows = stageModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        stageElement.getColumns().add(relationRowsElement);
                }
        }

        private void appendSequenceModel(dataflow dataflow, Table sequenceModel) {
                table sequenceElement = new table();
                sequenceElement.setId(String.valueOf(sequenceModel.getId()));
                if (!SQLUtil.isEmpty(sequenceModel.getDatabase())) {
                        sequenceElement.setDatabase(sequenceModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(sequenceModel.getSchema())) {
                        sequenceElement.setSchema(sequenceModel.getSchema());
                }
                sequenceElement.setServer(sequenceModel.getServer());
                sequenceElement.setName(sequenceModel.getName());
                sequenceElement.setType("sequence");
                sequenceElement.setLocation(sequenceModel.getLocation());
                if (sequenceModel.getFileType() != null) {
                        sequenceElement.setFileType(SQLUtil.trimColumnStringQuote(sequenceModel.getFileType()));
                }

                if (sequenceModel.getStartPosition() != null && sequenceModel.getEndPosition() != null) {
                        sequenceElement.setCoordinate(convertCoordinate(sequenceModel.getStartPosition()) + ","
                                        + convertCoordinate(sequenceModel.getEndPosition()));
                }

                if (sequenceModel.getProcesses() != null) {
                        List<String> processIds = new ArrayList<String>();
                        for (Process process : sequenceModel.getProcesses()) {
                                processIds.add(String.valueOf(process.getId()));
                        }
                        sequenceElement.setProcessIds(processIds);
                }
                dataflow.getSequences().add(sequenceElement);

                List<TableColumn> columns = sequenceModel.getColumns();

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = (TableColumn) columns.get(j);
                        column columnElement = new column();
                        columnElement.setId(String.valueOf(columnModel.getId()));
                        columnElement.setName(SQLUtil.trimColumnStringQuote(columnModel.getName()));
                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                        + convertCoordinate(columnModel.getEndPosition()));
                        sequenceElement.getColumns().add(columnElement);
                }

                TableRelationRows relationRows = sequenceModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        sequenceElement.getColumns().add(relationRowsElement);
                }
        }

        private void appendDataSourceModel(dataflow dataflow, Table datasourceModel) {
                table datasourceElement = new table();
                datasourceElement.setId(String.valueOf(datasourceModel.getId()));
                if (!SQLUtil.isEmpty(datasourceModel.getDatabase())) {
                        datasourceElement.setDatabase(datasourceModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(datasourceModel.getSchema())) {
                        datasourceElement.setSchema(datasourceModel.getSchema());
                }
                datasourceElement.setServer(datasourceModel.getServer());
                datasourceElement.setName(datasourceModel.getName());
                datasourceElement.setType("datasource");
                datasourceElement.setLocation(datasourceModel.getLocation());
                if (datasourceModel.getFileType() != null) {
                        datasourceElement.setFileType(SQLUtil.trimColumnStringQuote(datasourceModel.getFileType()));
                }

                if (datasourceModel.getStartPosition() != null && datasourceModel.getEndPosition() != null) {
                        datasourceElement.setCoordinate(convertCoordinate(datasourceModel.getStartPosition()) + ","
                                        + convertCoordinate(datasourceModel.getEndPosition()));
                }

                if (datasourceModel.getProcesses() != null) {
                        List<String> processIds = new ArrayList<String>();
                        for (Process process : datasourceModel.getProcesses()) {
                                processIds.add(String.valueOf(process.getId()));
                        }
                        datasourceElement.setProcessIds(processIds);
                }
                dataflow.getDatasources().add(datasourceElement);

                List<TableColumn> columns = datasourceModel.getColumns();

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = (TableColumn) columns.get(j);
                        column columnElement = new column();
                        columnElement.setId(String.valueOf(columnModel.getId()));
                        columnElement.setName(SQLUtil.trimColumnStringQuote(columnModel.getName()));
                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                        + convertCoordinate(columnModel.getEndPosition()));
                        datasourceElement.getColumns().add(columnElement);
                }

                TableRelationRows relationRows = datasourceModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        datasourceElement.getColumns().add(relationRowsElement);
                }
        }

        private void appendDatabaseModel(dataflow dataflow, Table databaseModel) {
                table databaseElement = new table();
                databaseElement.setId(String.valueOf(databaseModel.getId()));
                if (!SQLUtil.isEmpty(databaseModel.getDatabase())) {
                        databaseElement.setDatabase(databaseModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(databaseModel.getSchema())) {
                        databaseElement.setSchema(databaseModel.getSchema());
                }
                databaseElement.setServer(databaseModel.getServer());
                databaseElement.setName(databaseModel.getName());
                databaseElement.setType("database");
                if (databaseModel.getFileType() != null) {
                        databaseElement.setFileType(SQLUtil.trimColumnStringQuote(databaseModel.getFileType()));
                }

                if (databaseModel.getStartPosition() != null && databaseModel.getEndPosition() != null) {
                        databaseElement.setCoordinate(convertCoordinate(databaseModel.getStartPosition()) + ","
                                        + convertCoordinate(databaseModel.getEndPosition()));
                }

                if (databaseModel.getProcesses() != null) {
                        List<String> processIds = new ArrayList<String>();
                        for (Process process : databaseModel.getProcesses()) {
                                processIds.add(String.valueOf(process.getId()));
                        }
                        databaseElement.setProcessIds(processIds);
                }
                dataflow.getDatabases().add(databaseElement);

                List<TableColumn> columns = databaseModel.getColumns();

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = (TableColumn) columns.get(j);
                        column columnElement = new column();
                        columnElement.setId(String.valueOf(columnModel.getId()));
                        columnElement.setName(SQLUtil.trimColumnStringQuote(columnModel.getName()));
                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                        + convertCoordinate(columnModel.getEndPosition()));
                        databaseElement.getColumns().add(columnElement);
                }

                TableRelationRows relationRows = databaseModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        databaseElement.getColumns().add(relationRowsElement);
                }
        }

        private void appendSchemaModel(dataflow dataflow, Table schemaModel) {
                table schemaElement = new table();
                schemaElement.setId(String.valueOf(schemaModel.getId()));
                if (!SQLUtil.isEmpty(schemaModel.getDatabase())) {
                        schemaElement.setDatabase(schemaModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(schemaModel.getSchema())) {
                        schemaElement.setSchema(schemaModel.getSchema());
                }
                schemaElement.setServer(schemaModel.getServer());
                schemaElement.setName(schemaModel.getName());
                schemaElement.setType("schema");
                if (schemaModel.getFileType() != null) {
                        schemaElement.setFileType(SQLUtil.trimColumnStringQuote(schemaModel.getFileType()));
                }

                if (schemaModel.getStartPosition() != null && schemaModel.getEndPosition() != null) {
                        schemaElement.setCoordinate(convertCoordinate(schemaModel.getStartPosition()) + ","
                                        + convertCoordinate(schemaModel.getEndPosition()));
                }

                if (schemaModel.getProcesses() != null) {
                        List<String> processIds = new ArrayList<String>();
                        for (Process process : schemaModel.getProcesses()) {
                                processIds.add(String.valueOf(process.getId()));
                        }
                        schemaElement.setProcessIds(processIds);
                }
                dataflow.getSchemas().add(schemaElement);

                List<TableColumn> columns = schemaModel.getColumns();

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = (TableColumn) columns.get(j);
                        column columnElement = new column();
                        columnElement.setId(String.valueOf(columnModel.getId()));
                        columnElement.setName(SQLUtil.trimColumnStringQuote(columnModel.getName()));
                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                        + convertCoordinate(columnModel.getEndPosition()));
                        schemaElement.getColumns().add(columnElement);
                }

                TableRelationRows relationRows = schemaModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        schemaElement.getColumns().add(relationRowsElement);
                }
        }

        /**
         * Plan section 4.7: the identity an output merge keys a STRUCT field path node by, its declared column (by the
         * column's identifier key, else its legacy display bucket) and its path step by step; null for any other column.
         */
        private static Object fieldPathMergeKey(TableColumn column) {
                if (column == null || !column.isFieldPathNode() || column.getDeclaredColumn() == null) {
                        return null;
                }
                TableColumn declared = column.getDeclaredColumn();
                Object declaredKey = declared.getIdentifierKey() != null ? declared.getIdentifierKey()
                                : LegacyDlineageWireNamesV1.columnBucket(declared.getName());
                return java.util.Arrays.asList("field path", declaredKey, FieldNodeKey.of(column).getSteps());
        }

        private void appendPathModel(dataflow dataflow, Table pathModel) {
                table pathElement = new table();
                pathElement.setId(String.valueOf(pathModel.getId()));
                if (!SQLUtil.isEmpty(pathModel.getDatabase())) {
                        pathElement.setDatabase(pathModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(pathModel.getSchema())) {
                        pathElement.setSchema(pathModel.getSchema());
                }
                pathElement.setServer(pathModel.getServer());
                pathElement.setName(pathModel.getName());
                pathElement.setType("path");
                if (pathModel.getFileFormat() != null) {
                        pathElement.setFileFormat(SQLUtil.trimColumnStringQuote(pathModel.getFileFormat()));
                }

                if (pathModel.getStartPosition() != null && pathModel.getEndPosition() != null) {
                        pathElement.setCoordinate(convertCoordinate(pathModel.getStartPosition()) + ","
                                        + convertCoordinate(pathModel.getEndPosition()));
                }

                if (pathModel.getProcesses() != null) {
                        List<String> processIds = new ArrayList<String>();
                        for (Process process : pathModel.getProcesses()) {
                                processIds.add(String.valueOf(process.getId()));
                        }
                        pathElement.setProcessIds(processIds);
                }

                pathElement.setUri(pathModel.getPathUri() != null ? pathModel.getPathUri() : pathModel.getName());
                if (pathModel.getDataSourceName() != null) {
                        pathElement.setDataSourceName(pathModel.getDataSourceName());
                }
                // a file path a dynamic statement assembled at runtime (Mantis 4962); ordinary paths carry no endpoint attributes
                if (pathModel.isDynamicTemplate()) {
                        pathElement.setEndpointKind(EndpointKind.DYNAMIC_TEMPLATE.name());
                        pathElement.setTemplatedParts(pathModel.getTemplatedParts());
                }

                dataflow.getPaths().add(pathElement);

                // the files' columns with the fields an external table's declared STRUCT types read from them (Mantis 4858)
                List<TableColumn> columns = pathModel.getColumnsWithFieldPaths();

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = (TableColumn) columns.get(j);
                        column columnElement = new column();
                        columnElement.setId(String.valueOf(columnModel.getId()));
                        columnElement.setName(SQLUtil.trimColumnStringQuote(columnModel.getName()));
                        columnElement.setFieldPathKey(fieldPathMergeKey(columnModel));
                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                        + convertCoordinate(columnModel.getEndPosition()));
                        pathElement.getColumns().add(columnElement);
                }

                TableRelationRows relationRows = pathModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        pathElement.getColumns().add(relationRowsElement);
                }
        }

        private void appendVariableModel(dataflow dataflow, Table variableModel) {
                table variableElement = new table();
                variableElement.setId(String.valueOf(variableModel.getId()));
                if (!SQLUtil.isEmpty(variableModel.getDatabase())) {
                        variableElement.setDatabase(variableModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(variableModel.getSchema())) {
                        variableElement.setSchema(variableModel.getSchema());
                }
                variableElement.setServer(variableModel.getServer());
                variableElement.setName(variableModel.getName());
                variableElement.setType("variable");
                variableElement.setParent(variableModel.getParent());
                if (variableModel.getProcedureId() != null) {
                        variableElement.setProcedureId(variableModel.getProcedureId());
                }
                variableElement.setIsTarget(String.valueOf(variableModel.isTarget()));
                if (variableModel.getSubType() != null) {
                        variableElement.setSubType(variableModel.getSubType().name());
                }

                if (variableModel.getStartPosition() != null && variableModel.getEndPosition() != null) {
                        variableElement.setCoordinate(convertCoordinate(variableModel.getStartPosition()) + ","
                                        + convertCoordinate(variableModel.getEndPosition()));
                }
                dataflow.getVariables().add(variableElement);

                List<TableColumn> columns = variableModel.getColumns();

                if (containStarColumn(columns)) {
                        for (TableColumn column : columns) {
                                if (column.isStarColumn()) {
                                        for (TableColumn starElement : columns) {
                                                if (starElement == column) {
                                                        continue;
                                                }
                                                TObjectName columnObject = starElement.getColumnObject();
                                                column.bindStarLinkColumn(columnObject);
                                        }
//                                      column.setShowStar(false);
                                }
                        }
                }

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = columns.get(j);
                        if (columnModel.hasStarLinkColumn()) {
                                List<String> starLinkColumnList = columnModel.getStarLinkColumnNames();
                                for (int k = 0; k < starLinkColumnList.size(); k++) {
                                        column columnElement = new column();
                                        columnElement.setId(columnModel.getId() + "_" + k);
                                        columnElement.setIdentifierKey(columnModel.starLinkIdentifier(k));
                                        columnElement.setSqlSpelling(columnModel.starLinkSqlSpelling(k));
                                        String columnName = starLinkColumnList.get(k);
                                        if (containStarColumn(columns, columnModel, k)) {
                                                continue;
                                        }
                                        columnElement.setName(columnName);
                                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                                + convertCoordinate(columnModel.getEndPosition()));
                                        }
                                        variableElement.getColumns().add(columnElement);
                                }

                                if (columnModel.isShowStar()) {
                                        column columnElement = new column();
                                        columnElement.setId(String.valueOf(columnModel.getId()));
                                        columnElement.setName(columnModel.getName());
                                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                                        columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                                + convertCoordinate(columnModel.getEndPosition()));
                                        }
                                        variableElement.getColumns().add(columnElement);
                                }

                        } else {
                                column columnElement = new column();
                                columnElement.setId(String.valueOf(columnModel.getId()));
                                columnElement.setName(columnModel.getName());
                                DlineageUtil.publishStarProvenance(columnElement, columnModel);
                                columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                                if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                        + convertCoordinate(columnModel.getEndPosition()));
                                }
                                variableElement.getColumns().add(columnElement);
                        }
                }

                TableRelationRows relationRows = variableModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        variableElement.getColumns().add(relationRowsElement);
                }
        }

        private void appendCursorModel(dataflow dataflow, Table cursorModel) {
                table cursorElement = new table();
                cursorElement.setId(String.valueOf(cursorModel.getId()));
                if (!SQLUtil.isEmpty(cursorModel.getDatabase())) {
                        cursorElement.setDatabase(cursorModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(cursorModel.getSchema())) {
                        cursorElement.setSchema(cursorModel.getSchema());
                }
                cursorElement.setServer(cursorModel.getServer());
                cursorElement.setName(cursorModel.getName());
                cursorElement.setType("variable");
                if (cursorElement.getSubType() != null) {
                        cursorElement.setSubType(cursorModel.getSubType().name());
                }

                if (cursorModel.getStartPosition() != null && cursorModel.getEndPosition() != null) {
                        cursorElement.setCoordinate(convertCoordinate(cursorModel.getStartPosition()) + ","
                                        + convertCoordinate(cursorModel.getEndPosition()));
                }
                dataflow.getVariables().add(cursorElement);

                List<TableColumn> columns = cursorModel.getColumns();

                if (containStarColumn(columns)) {
                        for (TableColumn column : columns) {
                                if (column.isStarColumn()) {
                                        for (TableColumn starElement : columns) {
                                                if (starElement == column) {
                                                        continue;
                                                }
                                                TObjectName columnObject = starElement.getColumnObject();
                                                column.bindStarLinkColumn(columnObject);
                                        }
                                        column.setShowStar(false);
                                }
                        }
                }

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = (TableColumn) columns.get(j);
                        if (columnModel.hasStarLinkColumn()) {
                                List<String> starLinkColumnList = columnModel.getStarLinkColumnNames();
                                for (int k = 0; k < starLinkColumnList.size(); k++) {
                                        column columnElement = new column();
                                        columnElement.setId(String.valueOf(columnModel.getId()) + "_" + k);
                                        columnElement.setIdentifierKey(columnModel.starLinkIdentifier(k));
                                        columnElement.setSqlSpelling(columnModel.starLinkSqlSpelling(k));
                                        String columnName = starLinkColumnList.get(k);
                                        if (containStarColumn(columns, columnModel, k)) {
                                                continue;
                                        }
                                        columnElement.setName(columnName);
                                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                                + convertCoordinate(columnModel.getEndPosition()));
                                        }
                                        cursorElement.getColumns().add(columnElement);
                                }

                                if (columnModel.isShowStar()) {
                                        column columnElement = new column();
                                        columnElement.setId(String.valueOf(columnModel.getId()));
                                        columnElement.setName(columnModel.getName());
                                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                                        columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                                + convertCoordinate(columnModel.getEndPosition()));
                                        }
                                        cursorElement.getColumns().add(columnElement);
                                }

                        } else {
                                column columnElement = new column();
                                columnElement.setId(String.valueOf(columnModel.getId()));
                                columnElement.setName(columnModel.getName());
                                DlineageUtil.publishStarProvenance(columnElement, columnModel);
                                columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                                if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                        + convertCoordinate(columnModel.getEndPosition()));
                                }
                                cursorElement.getColumns().add(columnElement);
                        }
                }

                TableRelationRows relationRows = cursorModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        cursorElement.getColumns().add(relationRowsElement);
                }
        }

        private void appendErrors(dataflow dataflow) {
                List<ErrorInfo> errorInfos = this.getErrorMessages();
                if (metadataErrors != null) {
                        for (int i = 0; i < metadataErrors.size(); i++) {
                                errorInfos.add(i, metadataErrors.get(i));
                        }
                }

                for (int i = 0; i < errorInfos.size(); ++i) {
                        ErrorInfo errorInfo = errorInfos.get(i);
                        error error = new error();
                        if (!SQLUtil.isEmpty(errorInfo.getErrorMessage())) {
                                error.setErrorMessage(errorInfo.getErrorMessage());
                        }
                        if (!SQLUtil.isEmpty(errorInfo.getErrorType())) {
                                error.setErrorType(errorInfo.getErrorType());
                        }
                        if (errorInfo.getStartPosition() != null && errorInfo.getEndPosition() != null) {
                                error.setCoordinate(convertCoordinate(errorInfo.getStartPosition()) + ","
                                                + convertCoordinate(errorInfo.getEndPosition()));
                        }
                        if (!SQLUtil.isEmpty(errorInfo.getFileName())) {
                                error.setFile(errorInfo.getFileName());
                        }
                        if (errorInfo.getOriginStartPosition() != null && errorInfo.getOriginEndPosition() != null) {
                                error.setOriginCoordinate(errorInfo.getOriginStartPosition() + "," + errorInfo.getOriginEndPosition());
                        }
                        dataflow.getErrors().add(error);
                }
        }

        private void appendOraclePackages(dataflow dataflow) {
                List<OraclePackage> packages = this.modelManager.getOraclePackageModels();

                for (int i = 0; i < packages.size(); ++i) {
                        OraclePackage model = packages.get(i);
                        oraclePackage oraclePackage = new oraclePackage();
                        oraclePackage.setId(String.valueOf(model.getId()));
                        if (!SQLUtil.isEmpty(model.getDatabase())) {
                                oraclePackage.setDatabase(model.getDatabase());
                        }
                        if (!SQLUtil.isEmpty(model.getSchema())) {
                                oraclePackage.setSchema(model.getSchema());
                        }
                        oraclePackage.setServer(model.getServer());
                        oraclePackage.setName(model.getName());
                        if (model.getType() != null) {
                                oraclePackage.setType(model.getType().name().replace("sst", ""));
                        }
                        if (model.getStartPosition() != null && model.getEndPosition() != null) {
                                oraclePackage.setCoordinate(
                                                convertCoordinate(model.getStartPosition()) + "," + convertCoordinate(model.getEndPosition()));
                        }

                        oraclePackage.setComment(packageCommentOf(model));

                        dataflow.getPackages().add(oraclePackage);

                        List<Argument> arguments = model.getArguments();

                        for (int j = 0; j < arguments.size(); ++j) {
                                Argument argumentModel = (Argument) arguments.get(j);
                                argument argumentElement = new argument();
                                argumentElement.setId(String.valueOf(argumentModel.getId()));
                                argumentElement.setName(argumentModel.getName());
                                if (argumentModel.getStartPosition() != null && argumentModel.getEndPosition() != null) {
                                        argumentElement.setCoordinate(convertCoordinate(argumentModel.getStartPosition()) + ","
                                                        + convertCoordinate(argumentModel.getEndPosition()));
                                }

                                argumentElement.setDatatype(argumentModel.getDataType().getDataTypeName());
                                argumentElement.setInout(argumentModel.getMode().name());
                                oraclePackage.getArguments().add(argumentElement);
                        }

                        gudusoft.gsqlparser.TSourceToken packageBodyKeyword = packageBodyKeywordOf(model);
                        gudusoft.gsqlparser.TSourceToken memberBound = memberBoundOf(model, packageBodyKeyword);
                        for (int j = 0; j < model.getProcedures().size(); j++) {
                                Procedure procedureModel = model.getProcedures().get(j);
                                procedure procedure = new procedure();
                                procedure.setId(String.valueOf(procedureModel.getId()));
                                if (!SQLUtil.isEmpty(procedureModel.getDatabase())) {
                                        procedure.setDatabase(procedureModel.getDatabase());
                                }
                                if (!SQLUtil.isEmpty(procedureModel.getSchema())) {
                                        procedure.setSchema(procedureModel.getSchema());
                                }
                                procedure.setServer(procedureModel.getServer());
                                procedure.setName(procedureModel.getName());
                                // taken from the name as written, before normalized output renames it (DataflowUtility.routineKey)
                                procedure.setRoutineKey(DataflowUtility.routineKey(procedure.getName()));
                                if (procedureModel.getType() != null) {
                                        procedure.setType(procedureModel.getType().name().replace("sst", ""));
                                }
                                if (procedureModel.getStartPosition() != null && procedureModel.getEndPosition() != null) {
                                        procedure.setCoordinate(convertCoordinate(procedureModel.getStartPosition()) + ","
                                                        + convertCoordinate(procedureModel.getEndPosition()));
                                }

                                procedure.setComment(memberCommentOf(procedureModel.getProcedureObject(), memberBound));

                                oraclePackage.getProcedures().add(procedure);

                                List<Argument> procedureArguments = procedureModel.getArguments();

                                for (int k = 0; k < procedureArguments.size(); ++k) {
                                        Argument argumentModel = (Argument) procedureArguments.get(k);
                                        argument argumentElement = new argument();
                                        argumentElement.setId(String.valueOf(argumentModel.getId()));
                                        argumentElement.setName(argumentModel.getName());
                                        if (argumentModel.getStartPosition() != null && argumentModel.getEndPosition() != null) {
                                                argumentElement.setCoordinate(convertCoordinate(argumentModel.getStartPosition()) + ","
                                                                + convertCoordinate(argumentModel.getEndPosition()));
                                        }

                                        argumentElement.setDatatype(argumentModel.getDataType().getDataTypeName());
                                        argumentElement.setInout(argumentModel.getMode().name());
                                        procedure.getArguments().add(argumentElement);
                                }
                        }
                }
        }

        /**
         * The comment the author wrote directly above {@code node}, or {@code null} when the caller
         * did not ask for comments. Bounded at a blank line so a section header stays with its
         * section. See {@code Option.setShowComment(boolean)}.
         */
        private String commentOf(gudusoft.gsqlparser.nodes.TParseTreeNode node) {
                if (node == null || !option.isShowComment()) {
                        return null;
                }
                try {
                        String comment = node.getCommentBeforeNode(true);
                        return SQLUtil.isEmpty(comment) ? null : comment;
                } catch (Exception e) {
                        return null;
                }
        }

        /**
         * The package's header comment: the block that sits under the package declaration, after
         * {@code AS} / {@code IS}.
         *
         * <p>Read forward from that keyword rather than backward from the first procedure, because a
         * package may declare variables, types or cursors before any procedure, and a backward walk
         * stops at the first of those and loses the header.
         */
        private String packageCommentOf(gudusoft.gsqlparser.dlineage.dataflow.model.OraclePackage model) {
                if (model == null || !option.isShowComment()) {
                        return null;
                }
                String own = commentOf(model.getProcedureObject());
                if (!SQLUtil.isEmpty(own)) {
                        return own;
                }
                gudusoft.gsqlparser.TSourceToken bodyKeyword = packageBodyKeywordOf(model);
                if (bodyKeyword == null) {
                        return null;
                }
                try {
                        return gudusoft.gsqlparser.nodes.TParseTreeNode.commentBlockAfter(bodyKeyword);
                } catch (Exception e) {
                        return null;
                }
        }

        /**
         * The {@code AS} / {@code IS} that opens a package body, or {@code null}.
         *
         * <p>It is where the header comment starts, and it is also the boundary for the members: a
         * comment above the first procedure but below this keyword describes the package when nothing
         * separates it from the keyword, so the procedure's own scan must not run past it.
         */
        private gudusoft.gsqlparser.TSourceToken packageBodyKeywordOf(
                        gudusoft.gsqlparser.dlineage.dataflow.model.OraclePackage model) {
                if (model == null) {
                        return null;
                }
                gudusoft.gsqlparser.nodes.TParseTreeNode packageNode = model.getProcedureObject();
                if (packageNode == null || packageNode.getStartToken() == null) {
                        return null;
                }
                try {
                        gudusoft.gsqlparser.TSourceToken current = packageNode.getStartToken();
                        gudusoft.gsqlparser.TSourceToken stop = packageNode.getEndToken();
                        while (current != null) {
                                String text = current.toString();
                                if ("AS".equalsIgnoreCase(text) || "IS".equalsIgnoreCase(text)) {
                                        return current;
                                }
                                if (current == stop) {
                                        break;
                                }
                                current = current.getNextTokenInChain();
                        }
                } catch (Exception e) {
                        return null;
                }
                return null;
        }

        /**
         * The comment above a package member, minus the one the package already claimed.
         *
         * <p>The walk stops at the body keyword so it cannot wander into the package declaration, and
         * a block identical to the package's own comment is dropped: one comment, one owner. A member
         * that simply follows a header the package took from ELSEWHERE (a block written above
         * {@code CREATE PACKAGE BODY}) keeps its own.
         */
        /**
         * How far back a package member may look for its comment.
         *
         * <p>Past the body keyword is the package declaration, never a member's. And when the package
         * took its header from the block right after that keyword, the member may not reach that block
         * either — so the bound becomes the block's last token. If the package's comment came from
         * ABOVE its declaration instead, the block after the keyword was never claimed and belongs to
         * whichever member follows it. Deciding this from the tokens rather than by comparing text
         * keeps two objects that carry identical comments independent.
         */
        private gudusoft.gsqlparser.TSourceToken memberBoundOf(
                        gudusoft.gsqlparser.dlineage.dataflow.model.OraclePackage model,
                        gudusoft.gsqlparser.TSourceToken bodyKeyword) {
                if (bodyKeyword == null) {
                        return null;
                }
                if (!SQLUtil.isEmpty(commentOf(model.getProcedureObject()))) {
                        return bodyKeyword;   // the header came from above the declaration
                }
                gudusoft.gsqlparser.TSourceToken headerEnd =
                                gudusoft.gsqlparser.nodes.TParseTreeNode.commentBlockEndAfter(bodyKeyword);
                return headerEnd == null ? bodyKeyword : headerEnd;
        }

        private String memberCommentOf(gudusoft.gsqlparser.nodes.TParseTreeNode node,
                        gudusoft.gsqlparser.TSourceToken memberBound) {
                if (node == null || !option.isShowComment()) {
                        return null;
                }
                try {
                        String comment = node.getCommentBeforeNode(true, memberBound);
                        return SQLUtil.isEmpty(comment) ? null : comment;
                } catch (Exception e) {
                        return null;
                }
        }

        private void appendProcedures(dataflow dataflow) {
                List<Procedure> procedures = this.modelManager.getProcedureModels();

                for (int i = 0; i < procedures.size(); ++i) {
                        Procedure model = procedures.get(i);
                        if (model.getParentPackage() != null) {
                                continue;
                        }
                        procedure procedure = new procedure();
                        procedure.setId(String.valueOf(model.getId()));
                        if (!SQLUtil.isEmpty(model.getDatabase())) {
                                procedure.setDatabase(model.getDatabase());
                        }
                        if (!SQLUtil.isEmpty(model.getSchema())) {
                                procedure.setSchema(model.getSchema());
                        }
                        procedure.setServer(model.getServer());
                        procedure.setName(model.getName());
                        // taken from the name as written, before normalized output renames it (DataflowUtility.routineKey)
                        procedure.setRoutineKey(DataflowUtility.routineKey(procedure.getName()));
                        if (model.getType() != null) {
                                procedure.setType(model.getType().name().replace("sst", ""));
                        }
                        if (model.getStartPosition() != null && model.getEndPosition() != null) {
                                procedure.setCoordinate(
                                                convertCoordinate(model.getStartPosition()) + "," + convertCoordinate(model.getEndPosition()));
                        }

                        procedure.setComment(commentOf(model.getProcedureObject()));

                        dataflow.getProcedures().add(procedure);

                        List<Argument> arguments = model.getArguments();

                        for (int j = 0; j < arguments.size(); ++j) {
                                Argument argumentModel = (Argument) arguments.get(j);
                                argument argumentElement = new argument();
                                argumentElement.setId(String.valueOf(argumentModel.getId()));
                                argumentElement.setName(argumentModel.getName());
                                if (argumentModel.getStartPosition() != null && argumentModel.getEndPosition() != null) {
                                        argumentElement.setCoordinate(convertCoordinate(argumentModel.getStartPosition()) + ","
                                                        + convertCoordinate(argumentModel.getEndPosition()));
                                }

                                argumentElement.setDatatype(argumentModel.getDataType().getDataTypeName());
                                argumentElement.setInout(argumentModel.getMode().name());
                                procedure.getArguments().add(argumentElement);
                        }
                }
        }

        private void appendProcesses(dataflow dataflow) {
                List<Process> processes = this.modelManager.getProcessModels();

                for (int i = 0; i < processes.size(); ++i) {
                        Process model = processes.get(i);
                        process process = new process();
                        process.setId(String.valueOf(model.getId()));
                        if (!SQLUtil.isEmpty(model.getDatabase())) {
                                process.setDatabase(model.getDatabase());
                        }
                        if (!SQLUtil.isEmpty(model.getSchema())) {
                                process.setSchema(model.getSchema());
                        }
                        process.setServer(model.getServer());
                        process.setName(getProcessName(model));
                        if (!SQLUtil.isEmpty(model.getProcedureName())) {
                                process.setProcedureName(model.getProcedureName());
                        }
                        if (model.getProcedureId() != null) {
                                process.setProcedureId(String.valueOf(model.getProcedureId()));
                        }
                        if (!SQLUtil.isEmpty(model.getQueryHashId())) {
                                process.setQueryHashId(model.getQueryHashId());
                        }
                        if (model.getGspObject() != null) {
                                process.setType(model.getGspObject().sqlstatementtype.name());
                        }
                        if (model.getStartPosition() != null && model.getEndPosition() != null) {
                                process.setCoordinate(
                                                convertCoordinate(model.getStartPosition()) + "," + convertCoordinate(model.getEndPosition()));
                        }
                        if (model.getTransforms() != null && !model.getTransforms().isEmpty()) {
                                for (Transform transformItem : model.getTransforms()) {
                                        process.addTransform(transformItem);
                                }
                        }
                        dataflow.getProcesses().add(process);
                }
        }

        private void appendTables(dataflow dataflow) {
                List<TTable> tables = modelManager.getBaseTables();
                Map<Object, table> tableMap = new HashMap<Object, table>();
                Set<Long> tableModelIds = new HashSet<Long>();
                for (int i = 0; i < tables.size(); i++) {
                        Object model = modelManager.getModel(tables.get(i));
                        if (model instanceof Table) {
                                Table tableModel = (Table) model;
                                if(tableModelIds.contains(tableModel.getId())) {
                                        continue;
                                }
                                else {
                                        tableModelIds.add(tableModel.getId());
                                }
                                if (tableModel.isView()) {
                                        continue;
                                }
                                if (tableModel.isStage()) {
                                        appendStageModel(dataflow, tableModel);
                                        continue;
                                }
                                if (tableModel.isSequence()) {
                                        appendSequenceModel(dataflow, tableModel);
                                        continue;
                                }
                                if (tableModel.isDataSource()) {
                                        appendDataSourceModel(dataflow, tableModel);
                                        continue;
                                }
                                if (tableModel.isDatabase()) {
                                        appendDatabaseModel(dataflow, tableModel);
                                        continue;
                                }
                                if (tableModel.isSchema()) {
                                        appendSchemaModel(dataflow, tableModel);
                                        continue;
                                }
                                if (tableModel.isStream()) {
                                        appendStreamModel(dataflow, tableModel);
                                        continue;
                                }
                                if (tableModel.isPath()) {
                                        appendPathModel(dataflow, tableModel);
                                        continue;
                                }
                                if (tableModel.isVariable() && !tableModel.isCursor()) {
                                        appendVariableModel(dataflow, tableModel);
                                        continue;
                                }
                                if (tableModel.isCursor()) {
                                        appendCursorModel(dataflow, tableModel);
                                        continue;
                                }
                                if (tableModel.isConstant()) {
                                        appendConstantModel(dataflow, tableModel);
                                        continue;
                                }
                                if (!tableIds.contains(tableModel.getId())) {
                                        appendTableModel(dataflow, tableModel, tableMap);
                                        tableIds.add(tableModel.getId());
                                }
                        } else if (model instanceof QueryTable) {
                                QueryTable queryTable = (QueryTable) model;
                                if (!tableIds.contains(queryTable.getId())) {
                                        appendResultSet(dataflow, queryTable);
                                        tableIds.add(queryTable.getId());
                                }
                        }
                }

                List<Table> tableNames = modelManager.getTablesByName();
                tableNames.addAll(modelManager.getDropTables());
                
                for (int i = 0; i < tableNames.size(); i++) {
                        Table tableModel = tableNames.get(i);
                        if(tableModelIds.contains(tableModel.getId())) {
                                continue;
                        }
                        else {
                                tableModelIds.add(tableModel.getId());
                        }
                        if (tableModel.isView()) {
                                continue;
                        }
                        if (tableModel.isDatabase()) {
                                appendDatabaseModel(dataflow, tableModel);
                                continue;
                        }
                        if (tableModel.isSchema()) {
                                appendSchemaModel(dataflow, tableModel);
                                continue;
                        }
                        if (tableModel.isStage()) {
                                appendStageModel(dataflow, tableModel);
                                continue;
                        }
                        if (tableModel.isSequence()) {
                                appendSequenceModel(dataflow, tableModel);
                                continue;
                        }
                        if (tableModel.isDataSource()) {
                                appendDataSourceModel(dataflow, tableModel);
                                continue;
                        }
                        if (tableModel.isStream()) {
                                appendStreamModel(dataflow, tableModel);
                                continue;
                        }
                        if (tableModel.isPath()) {
                                appendPathModel(dataflow, tableModel);
                                continue;
                        }
                        if (tableModel.isVariable()) {
                                appendVariableModel(dataflow, tableModel);
                                continue;
                        }
                        if (tableModel.isCursor()) {
                                appendCursorModel(dataflow, tableModel);
                                continue;
                        }
                        if (tableModel.isConstant()) {
                                appendConstantModel(dataflow, tableModel);
                                continue;
                        }
                        if (!tableIds.contains(tableModel.getId())) {
                                appendTableModel(dataflow, tableModel, tableMap);
                                tableIds.add(tableModel.getId());
                        }
                }
        }

        private void appendConstantModel(dataflow dataflow, Table tableModel) {
                table constantElement = new table();
                constantElement.setId(String.valueOf(tableModel.getId()));
                if (!SQLUtil.isEmpty(tableModel.getDatabase())) {
                        constantElement.setDatabase(tableModel.getDatabase());
                }
                if (!SQLUtil.isEmpty(tableModel.getSchema())) {
                        constantElement.setSchema(tableModel.getSchema());
                }
                constantElement.setServer(tableModel.getServer());
                constantElement.setName(getConstantName(tableModel));
                constantElement.setType("constantTable");

                if (tableModel.getStartPosition() != null && tableModel.getEndPosition() != null) {
                        constantElement.setCoordinate(convertCoordinate(tableModel.getStartPosition()) + ","
                                        + convertCoordinate(tableModel.getEndPosition()));
                }
                dataflow.getTables().add(constantElement);

                List<TableColumn> columns = tableModel.getColumns();
                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = (TableColumn) columns.get(j);
                        column columnElement = new column();
                        columnElement.setId(String.valueOf(columnModel.getId()));
                        columnElement.setName(columnModel.getName());
                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                        columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                + convertCoordinate(columnModel.getEndPosition()));
                        }
                        constantElement.getColumns().add(columnElement);
                }
        }

        /**
         * Copies the authoritative endpoint classification from the internal model onto the
         * XML element, emitting each field ONLY when it carries information (kind/intro not
         * UNKNOWN, createdInSql only when true, normalizedName only when it differs from the
         * raw name). This keeps existing XML byte-identical for endpoints that aren't
         * classified, honouring the strictly-additive contract (§9 of
         * docs/tmp/dlineage-authoritative-endpoint-classification.md).
         */
        private void appendEndpointClassification(table tableElement, Table tableModel) {
                if (ModelBindingManager.isScopedTemporary(tableModel.getTableObject())) tableElement.setScopedTemporary(true);
                if (tableModel.isArrayRelation()) {
                        tableElement.setArrayRelation(true);
                }
                boolean created = tableModel.isCreatedInSql();
                EndpointKind kind = tableModel.getEndpointKind();
                // Emit endpointKind only when it carries signal: a non-catalog special kind
                // (temp / global-temp / table-variable / tempdb) always, or CATALOG_OBJECT only
                // when the object is created here. A plainly-referenced catalog table is the
                // default case and carries no attribute, so existing golden XML for ordinary
                // table references stays byte-identical.
                if (kind != null && kind != EndpointKind.UNKNOWN
                                && (created || kind != EndpointKind.CATALOG_OBJECT)) {
                        tableElement.setEndpointKind(kind.name());
                }
                EndpointIntroduction intro = tableModel.getEndpointIntroduction();
                if (intro != null && intro != EndpointIntroduction.UNKNOWN) {
                        tableElement.setEndpointIntroduction(intro.name());
                }
                if (created) {
                        tableElement.setCreatedInSql("true");
                }
                // Which name segments a dynamic fold assembled at runtime. Present only on endpoints
                // the analyzer marked inside a fold context, so ordinary output is untouched.
                if (tableModel.getTemplatedParts() != null) {
                        tableElement.setTemplatedParts(tableModel.getTemplatedParts());
                }
                // Emit normalizedName only when the raw name actually carries delimiters
                // (brackets / quotes / backticks) — that is when the normalized form is useful
                // and not trivially derivable. Avoids case-only churn on every plain name.
                // A templated endpoint always gets it: consumers match the delimiter-free skeleton
                // against later-resolved concrete names, and an unbracketed concatenation
                // ('RECON_' + @X + '_t') carries no delimiter to trigger the test above.
                String rawName = tableModel.getName();
                if (rawName != null && (hasIdentifierDelimiter(rawName) || tableModel.isDynamicTemplate())) {
                        String normalized = tableModel.getNormalizedName();
                        if (normalized != null && !normalized.equals(rawName)) {
                                tableElement.setNormalizedName(normalized);
                        }
                }
        }

        private static boolean hasIdentifierDelimiter(String name) {
                return name.indexOf('[') != -1 || name.indexOf(']') != -1
                                || name.indexOf('`') != -1 || name.indexOf('"') != -1;
        }

        private void appendTableModel(dataflow dataflow, Table tableModel, Map<Object, table> tableMap) {
                if(tableModel.getSubType() == SubType.unnest) {}
                table tableElement = new table();
                tableElement.setIdentifierKey(tableModel.getIdentifierKey());
                tableElement.setMergeIdentity(tableModel.getCanonicalIdentity());
                tableElement.setId(String.valueOf(tableModel.getId()));
                // A one-part name that is ambiguous across two or more schemas (with no object
                // in the default schema) must NOT be bound to a fabricated default-schema
                // object: surface it unqualified and expose the candidate set instead.
                boolean ambiguousUnqualified = tableModel.isAmbiguousUnqualifiedTable()
                                && tableModel.getCandidateTables() != null
                                && !tableModel.getCandidateTables().isEmpty();
                if (!ambiguousUnqualified) {
                        if (!SQLUtil.isEmpty(tableModel.getDatabase())) {
                                tableElement.setDatabase(tableModel.getDatabase());
                        }
                        if (!SQLUtil.isEmpty(tableModel.getSchema())) {
                                tableElement.setSchema(tableModel.getSchema());
                        }
                }
                tableElement.setServer(tableModel.getServer());
                if (ambiguousUnqualified) {
                        tableElement.setName(DlineageUtil.getSimpleTableName(tableModel.getName()));
                        tableElement.setCandidateTables(new ArrayList<String>(tableModel.getCandidateTables()));
                } else {
                        tableElement.setName(tableModel.getName());
                }
                tableElement.setDisplayName(tableModel.getDisplayName());
                tableElement.setStarStmt(tableModel.getStarStmt());
                if(tableModel.isFromDDL()) {
                        tableElement.setFromDDL(String.valueOf(tableModel.isFromDDL()));
                }
                // Authoritative endpoint classification (additive). Emit only non-default
                // values so existing XML stays byte-identical for unclassified endpoints.
                // See docs/tmp/dlineage-authoritative-endpoint-classification.md.
                appendEndpointClassification(tableElement, tableModel);

                if (tableModel.isPseudo()) {
                        tableElement.setType("pseudoTable");
                } else {
                        tableElement.setType("table");
                }

                if (tableModel.getSubType() != null) {
                        if (tableModel.getSubType() == SubType.unnest) {
                                tableElement.setType(SubType.unnest.name());
                        }
                        else {
                                tableElement.setSubType(tableModel.getSubType().name());
                        }
                }
                if (tableModel.getParent() != null) {
                        tableElement.setParent(tableModel.getParent());
                }
                if (tableModel.getAlias() != null && tableModel.getAlias().trim().length() > 0) {
                        tableElement.setAlias(tableModel.getAlias());
                }
                if (tableModel.getStartPosition() != null && tableModel.getEndPosition() != null) {
            if(option.isTraceTablePosition()){
                for (Pair<Pair3<Long, Long, String>, Pair3<Long, Long, String>> position:tableModel.getPositions()){
                    tableElement.appendCoordinate(convertCoordinate(position.first)+","+convertCoordinate(position.second));
                }
            }
            else {
                tableElement.setCoordinate(convertCoordinate(tableModel.getStartPosition()) + ","
                    + convertCoordinate(tableModel.getEndPosition()));
            }
                }
                if (tableModel.getProcesses() != null) {
                        List<String> processIds = new ArrayList<String>();
                        for (Process process : tableModel.getProcesses()) {
                                processIds.add(String.valueOf(process.getId()));
                        }
                        tableElement.setProcessIds(processIds);
                }

                table oldTableElement = null;
                // The elements that share column metadata: by the BigQuery key, else by the bucket of the qualified published
                // name. Not by mergeIdentity: it is not qualified alike for one table (a table a DDL creates carries employee,
                // a reference to it default.employee), and keying by it keeps one table's elements from sharing their column
                // types. Two tables the analysis keeps apart publish names of their own (NormalNameCollisions), so their
                // buckets differ (TableMetadataIdentityTest).
                Object tableFullName = tableElement.getIdentifierKey() != null ? tableElement.getIdentifierKey()
                                : LegacyDlineageWireNamesV1.tableBucket(DlineageUtil.getQualifiedTableName(tableElement));
                if (tableElement.isArrayRelation()) {
                        // a LATERAL VIEW's relation shares nothing with a table of its name (Mantis 4890)
                        tableFullName = Arrays.asList("array relation", tableModel.getId());
                }
                
                if(tableMap.containsKey(tableFullName)) {
                        oldTableElement = tableMap.get(tableFullName);
                }
                else {
                        tableMap.put(tableFullName, tableElement);
                }
                
                if (tableModel.getSubType() == SubType.unnest) {
                        dataflow.getResultsets().add(tableElement);
                } else {
                        dataflow.getTables().add(tableElement);
                }

                List<TableColumn> columns = tableModel.getColumns();

                if (containStarColumn(columns)) {
                        for (TableColumn column : columns) {
                                if (column.isStarColumn()) {
                                        for (TableColumn starElement : columns) {
                                                if (starElement == column) {
                                                        continue;
                                                }
                                                if (starElement.isNotBindStarLinkColumn()) {
                                                        continue;
                                                }
                                                TObjectName columnObject = starElement.getColumnObject();
                                                column.bindStarLinkColumn(columnObject);
                                        }
                                        if (tableModel.isCreateTable() && column.isExpandStar()) {
                                                column.setShowStar(false);
                                        }
                                }
                        }
                }

                // each column followed by the STRUCT field path nodes below it
                List<TableColumn> publishedColumns = tableModel.getColumnsWithFieldPaths();
                for (int j = 0; j < publishedColumns.size(); j++) {
                        TableColumn columnModel = publishedColumns.get(j);

                        if(oldTableElement != null){
                                if(!CollectionUtil.isEmpty(oldTableElement.getColumns())){
                                        for(column oldColumnElement: oldTableElement.getColumns()){
                                                if(SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, oldColumnElement.getName(), columnModel.getName())){
                                                        if(columnModel.getDataType() == null && oldColumnElement.getDataType() != null){
                                                                columnModel.setDataType(oldColumnElement.getDataType());
                                                        }
                                                        if(columnModel.getPrimaryKey() == null && oldColumnElement.isPrimaryKey() != null){
                                                                columnModel.setPrimaryKey(oldColumnElement.isPrimaryKey());
                                                        }
                                                        if(columnModel.getIndexKey() == null && oldColumnElement.isIndexKey() != null){
                                                                columnModel.setIndexKey(oldColumnElement.isIndexKey());
                                                        }
                                                        if(columnModel.getUnqiueKey() == null && oldColumnElement.isUnqiueKey() != null){
                                                                columnModel.setUnqiueKey(oldColumnElement.isUnqiueKey());
                                                        }
                                                        if(columnModel.getForeignKey() == null && oldColumnElement.isForeignKey() != null){
                                                                columnModel.setForeignKey(oldColumnElement.isForeignKey());
                                                        }

                                                        if(oldColumnElement.getDataType() == null && columnModel.getDataType() != null){
                                                                oldColumnElement.setDataType(columnModel.getDataType());
                                                        }
                                                        if(oldColumnElement.isPrimaryKey() == null && columnModel.getPrimaryKey() != null){
                                                                oldColumnElement.setPrimaryKey(columnModel.getPrimaryKey());
                                                        }
                                                        if(oldColumnElement.isIndexKey() == null && columnModel.getIndexKey() != null){
                                                                oldColumnElement.setIndexKey(columnModel.getIndexKey());
                                                        }
                                                        if(oldColumnElement.isUnqiueKey() == null && columnModel.getUnqiueKey() != null){
                                                                oldColumnElement.setUnqiueKey(columnModel.getUnqiueKey());
                                                        }
                                                        if(oldColumnElement.isForeignKey() == null && columnModel.getForeignKey() != null){
                                                                oldColumnElement.setForeignKey(columnModel.getForeignKey());
                                                        }
                                                        break;
                                                }
                                        }
                                }

                        }

                        if (!columnModel.isPseduo() && columnModel.hasStarLinkColumn() && !columnModel.isVariant()) {
                                List<String> starLinkColumnList = columnModel.getStarLinkColumnNames();
                                for (int k = 0; k < starLinkColumnList.size(); k++) {
                                        column columnElement = new column();
                                        columnElement.setId(String.valueOf(columnModel.getId()) + "_" + k);
                                        columnElement.setIdentifierKey(columnModel.starLinkIdentifier(k));
                                        columnElement.setSqlSpelling(columnModel.starLinkSqlSpelling(k));
                                        String columnName = starLinkColumnList.get(k);
                                        if (containStarColumn(columns, columnModel, k)) {
                                                continue;
                                        }
                                        columnElement.setName(columnName);
                                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                                + convertCoordinate(columnModel.getEndPosition()));
                                        }
                                        if (columnModel.getForeignKey()) {
                                                columnElement.setForeignKey(columnModel.getForeignKey());
                                        }
                                        if (columnModel.getIndexKey()) {
                                                columnElement.setIndexKey(columnModel.getIndexKey());
                                        }
                                        if (columnModel.getPrimaryKey()) {
                                                columnElement.setPrimaryKey(columnModel.getPrimaryKey());
                                        }
                                        if (columnModel.getUnqiueKey()) {
                                                columnElement.setUnqiueKey(columnModel.getUnqiueKey());
                                        }
                                        if (columnModel.getDataType() != null) {
                                                columnElement.setDataType(columnModel.getDataType());
                                        }
                                        tableElement.getColumns().add(columnElement);
                                }
                                if (columnModel.isShowStar()) {
                                        column columnElement = new column();
                                        columnElement.setId(String.valueOf(columnModel.getId()));
                                        columnElement.setName(columnModel.getName());
                                        DlineageUtil.publishStarProvenance(columnElement, columnModel);
                                        columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                                        columnElement.setFieldPathKey(fieldPathMergeKey(columnModel));
                                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                                + convertCoordinate(columnModel.getEndPosition()));
                                        }
                                        if (columnModel.getForeignKey()) {
                                                columnElement.setForeignKey(columnModel.getForeignKey());
                                        }
                                        if (columnModel.getIndexKey()) {
                                                columnElement.setIndexKey(columnModel.getIndexKey());
                                        }
                                        if (columnModel.getPrimaryKey()) {
                                                columnElement.setPrimaryKey(columnModel.getPrimaryKey());
                                        }
                                        if (columnModel.getUnqiueKey()) {
                                                columnElement.setUnqiueKey(columnModel.getUnqiueKey());
                                        }
                                        if (columnModel.getDataType() != null) {
                                                columnElement.setDataType(columnModel.getDataType());
                                        }
                                        tableElement.getColumns().add(columnElement);
                                }
                        } else {
                                column columnElement = new column();
                                columnElement.setId(String.valueOf(columnModel.getId()));
                                columnElement.setName(columnModel.getName());
                                DlineageUtil.publishStarProvenance(columnElement, columnModel);
                                columnElement.setIdentifierKey(columnModel.getIdentifierKey());
                                columnElement.setFieldPathKey(fieldPathMergeKey(columnModel));
                                columnElement.setDisplayName(columnModel.getDisplayName());
                                if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                        + convertCoordinate(columnModel.getEndPosition()));
                                }
                                if (columnModel.isPseduo()) {
                                        columnElement.setSource("system");
                                }
                                if (columnModel.getForeignKey()) {
                                        columnElement.setForeignKey(columnModel.getForeignKey());
                                }
                                if (columnModel.getIndexKey()) {
                                        columnElement.setIndexKey(columnModel.getIndexKey());
                                }
                                if (columnModel.getPrimaryKey()) {
                                        columnElement.setPrimaryKey(columnModel.getPrimaryKey());
                                }
                                if (columnModel.getUnqiueKey()) {
                                        columnElement.setUnqiueKey(columnModel.getUnqiueKey());
                                }
                                if (columnModel.getDataType() != null) {
                                        columnElement.setDataType(columnModel.getDataType());
                                }
                                tableElement.getColumns().add(columnElement);
                        }
                }

                TableRelationRows relationRows = tableModel.getRelationRows();
                if (relationRows.hasRelation()) {
                        column relationRowsElement = new column();
                        relationRowsElement.setId(String.valueOf(relationRows.getId()));
                        relationRowsElement.setName(relationRows.getName());
                        if (relationRows.getStartPosition() != null && relationRows.getEndPosition() != null) {
                                relationRowsElement.setCoordinate(convertCoordinate(relationRows.getStartPosition()) + ","
                                                + convertCoordinate(relationRows.getEndPosition()));
                        }
                        relationRowsElement.setSource("system");
                        tableElement.getColumns().add(relationRowsElement);
                }
        }

        /** Whether one of {@code columns} publishes the name of the star link at {@code ordinal} of {@code link}. */
        private boolean containStarColumn(List<TableColumn> columns, Column link, int ordinal) {
                for (TableColumn tableColumn : columns) {
                        if (link.starLinkNamesColumn(ordinal, tableColumn)) {
                                return true;
                        }
                }
                return false;
        }

        /** Whether one of the column {@code elements} publishes the name of the star link at {@code ordinal} of {@code link}. */
        private boolean containStarColumn(Collection<RelationshipElement<?>> elements, Column link, int ordinal) {
                for (RelationshipElement element : elements) {
                        if (element.getElement() instanceof TableColumn || element.getElement() instanceof ResultColumn) {
                                if (link.starLinkNamesColumn(ordinal, (Column) element.getElement())) {
                                        return true;
                                }
                        }
                }
                return false;
        }

        /**
         * Returns true if there is a non-star source element matching the column name
         * whose parent (table/resultset) does NOT also contribute a star source in
         * the same relationship. This identifies "definitive" explicit sources like
         * subquery columns (e.g., "coalesce(...) as col_a") vs incidental references
         * (e.g., "aTab.id" where aTab.* is also a source).
         */
        private boolean hasDefinitiveNonStarSource(Collection<RelationshipElement<?>> elements, StarLinkMatcher targetLink) {
                // First, collect parent IDs of all star (*) sources
                Set<Long> starSourceParentIds = new HashSet<Long>();
                for (RelationshipElement<?> element : elements) {
                        if (element.getElement() instanceof TableColumn) {
                                TableColumn tc = (TableColumn) element.getElement();
                                if (tc.isStarColumn() && tc.getTable() != null) {
                                        starSourceParentIds.add(tc.getTable().getId());
                                }
                        } else if (element.getElement() instanceof ResultColumn) {
                                ResultColumn rc = (ResultColumn) element.getElement();
                                if (rc.isStarColumn() && rc.getResultSet() != null) {
                                        starSourceParentIds.add(rc.getResultSet().getId());
                                }
                        }
                }

                // Then check if any non-star source matching the column name has a parent
                // that does NOT also have a star source
                for (RelationshipElement<?> element : elements) {
                        if (element.getElement() instanceof TableColumn) {
                                TableColumn tc = (TableColumn) element.getElement();
                                if (!tc.isStarColumn() && targetLink.isNamedBy(tc)) {
                                        if (tc.getTable() != null && !starSourceParentIds.contains(tc.getTable().getId())) {
                                                return true;
                                        }
                                }
                        } else if (element.getElement() instanceof ResultColumn) {
                                ResultColumn rc = (ResultColumn) element.getElement();
                                if (!rc.isStarColumn() && targetLink.isNamedBy(rc)) {
                                        if (rc.getResultSet() != null && !starSourceParentIds.contains(rc.getResultSet().getId())) {
                                                return true;
                                        }
                                }
                        }
                }
                return false;
        }

        /** The USING columns of each SELECT's own FROM clause, collected once per statement and parse. */
        private final Map<TSelectSqlStatement, List<TObjectName>> usingColumnsByStatement =
                        new IdentityHashMap<TSelectSqlStatement, List<TObjectName>>();

        /** resolver2's scopes of the statements being analyzed, or null when resolver2 did not run. */
        private ScopeBuildResult scopeBuildResult;

        /**
         * Whether {@code tableColumn} of {@code sourceTable}, colliding in this {@code SELECT *} with a column of the same
         * identity that {@code earlierTables} published, is one column of a {@code JOIN ... USING} of this SELECT: a USING
         * of its own FROM clause lists that column, and the join merges every table involved (resolver2's
         * {@link gudusoft.gsqlparser.resolver2.scope.SelectScope#findCoveringMerge UsingMerge} participants). A third relation carrying the name stays a
         * separate column, and a USING in a subquery merges nothing here.
         *
         * <p>This used to be the regex {@code (?is).*using\s*\(\s*<name>\s*\).*} over the rendered statement, run for
         * every colliding column: it spliced the name in unescaped, saw a USING list only when it held that one column,
         * matched text in comments and in subqueries, and compared the published name, which has lost its quotes.
         */
        private boolean isUsingMerged(TSelectSqlStatement stmt, TableColumn tableColumn, TTable sourceTable,
                        List<TTable> earlierTables) {
                gudusoft.gsqlparser.resolver2.scope.SelectScope scope = scopeBuildResult == null ? null
                                : scopeBuildResult.getScopeForStatement(stmt);
                for (TObjectName usingColumn : usingColumnsOf(stmt)) {
                        if (!namesSameColumn(usingColumn, tableColumn)) {
                                continue;
                        }
                        if (scope == null) {
                                // resolver2 has no scope for this statement: its own USING lists decide alone
                                return true;
                        }
                        List<TTable> candidates = new ArrayList<TTable>(earlierTables);
                        candidates.add(sourceTable);
                        // the spelling resolver2 recorded for this USING column, so the merge is found by its participants
                        String spelling = usingColumn.getColumnNameOnly();
                        if (spelling == null || spelling.isEmpty()) {
                                spelling = usingColumn.toString();
                        }
                        if (scope.findCoveringMerge(option.getVendor(), spelling, candidates) != null) {
                                return true;
                        }
                }
                return false;
        }

        /** A USING column and a table column are one column when their identities are, else when their names are. */
        private static boolean namesSameColumn(TObjectName usingColumn, TableColumn tableColumn) {
                Object key = tableColumn.getIdentifierKey();
                Object usingKey = DlineageUtil.columnKey(usingColumn);
                if (key != null && usingKey != null) {
                        return key.equals(usingKey);
                }
                return DlineageUtil.sameColumnName(tableColumn.getName(), usingColumn);
        }

        /** The USING columns of the joins of {@code stmt}'s own FROM clause, not of its subqueries. */
        private List<TObjectName> usingColumnsOf(TSelectSqlStatement stmt) {
                List<TObjectName> columns = usingColumnsByStatement.get(stmt);
                if (columns != null) {
                        return columns;
                }
                columns = new ArrayList<TObjectName>();
                if (stmt.joins != null) {
                        for (int i = 0; i < stmt.joins.size(); i++) {
                                TJoin join = stmt.joins.getJoin(i);
                                if (join == null || join.getJoinItems() == null) {
                                        continue;
                                }
                                for (int j = 0; j < join.getJoinItems().size(); j++) {
                                        TJoinItem item = join.getJoinItems().getJoinItem(j);
                                        if (item != null) {
                                                addUsingColumns(columns, item.getUsingColumns());
                                        }
                                }
                        }
                }
                Deque<TTable> pending = new ArrayDeque<TTable>();
                if (stmt.getRelations() != null) {
                        pending.addAll(stmt.getRelations());
                }
                while (!pending.isEmpty()) {
                        TTable relation = pending.pop();
                        if (relation == null || relation.getTableType() != ETableSource.join || relation.getJoinExpr() == null) {
                                continue;
                        }
                        TJoinExpr join = relation.getJoinExpr();
                        addUsingColumns(columns, join.getUsingColumns());
                        if (join.getLeftTable() != null) {
                                pending.push(join.getLeftTable());
                        }
                        if (join.getRightTable() != null) {
                                pending.push(join.getRightTable());
                        }
                }
                usingColumnsByStatement.put(stmt, columns);
                return columns;
        }

        private static void addUsingColumns(List<TObjectName> found, TObjectNameList columns) {
                if (columns == null) {
                        return;
                }
                for (int i = 0; i < columns.size(); i++) {
                        found.add(columns.getObjectName(i));
                }
        }

        private void analyzeSelectStmt(TSelectSqlStatement stmt) {
                // SQL-LR: a nested analysis never inherits the reference of the loop that called it
                SqllrObservations sqllr = modelManager.getSqllrObservations();
                int sqllrBarrier = sqllr == null ? -1 : sqllr.openFrame();
                try {
                        analyzeSelectStmtInSqllrBarrier(stmt);
                } finally {
                        if (sqllr != null) {
                                sqllr.closeFrame(sqllrBarrier);
                        }
                }
        }

        private void analyzeSelectStmtInSqllrBarrier(TSelectSqlStatement stmt) {
                if (!accessedSubqueries.contains(stmt)) {
                        accessedSubqueries.add(stmt);
                } else {
                        if (modelManager.getModel(stmt) != null) {
                                return;
                        }
                }

                // ClickHouse external table functions must be modelled BEFORE the
                // select-list relations are analyzed: the column path resolves its
                // source through modelManager.getModel(table), and without an early
                // binding it materializes a generic function node and the external
                // upstream silently vanishes.
                if (option.getVendor() == EDbVendor.dbvclickhouse && stmt.getRelations() != null) {
                        for (TTable lcTable : stmt.getRelations()) {
                                TFunctionCall lcFuncCall = lcTable.getFuncCall();
                                if (lcFuncCall == null && lcTable.getTableExpr() != null) {
                                        lcFuncCall = lcTable.getTableExpr().getFunctionCall();
                                }
                                if (lcFuncCall != null) {
                                        modelClickhouseExternalTableFunction(lcTable, lcFuncCall);
                                }
                        }
                }

                if (stmt.getParentStmt() == null && stmt.getIntoClause() == null && stmt.getIntoTableClause() == null) {
                        if(option.isIgnoreTopSelect() && (option.isIgnoreRecordSet() || option.isSimpleOutput())){
                                if(option.getAnalyzeMode() == null || option.getAnalyzeMode() == AnalyzeMode.dataflow){
                                        return;
                                }
                        }
                }

                if (stmt.getSetOperatorType() != ESetOperatorType.none) {

                        // Iteratively analyze all descendant UNION branches before processing this node.
                        // Uses iterative post-order traversal to preserve the original left-right-self
                        // processing order, avoiding StackOverflow with deeply nested UNION trees.
                        {
                                Deque<TSelectSqlStatement> stack1 = new ArrayDeque<>();
                                List<TSelectSqlStatement> postOrder = new ArrayList<>();
                                stack1.push(stmt);
                                while (!stack1.isEmpty()) {
                                        TSelectSqlStatement node = stack1.pop();
                                        postOrder.add(node);
                                        if (node.getSetOperatorType() != ESetOperatorType.none) {
                                                // Push left first, then right, so that after reversal left comes first
                                                if (node.getLeftStmt() != null) stack1.push(node.getLeftStmt());
                                                if (node.getRightStmt() != null) stack1.push(node.getRightStmt());
                                        }
                                }
                                Collections.reverse(postOrder);
                                // Process all descendants in post-order, skip stmt itself (processed below)
                                for (int pi = 0; pi < postOrder.size() - 1; pi++) {
                                        TSelectSqlStatement node = postOrder.get(pi);
                                        if (!accessedStatements.contains(node)) {
                                                accessedStatements.add(node);
                                                analyzeSelectStmt(node);
                                        }
                                }
                        }

                        stmtStack.push(stmt);
                        SelectSetResultSet resultSet = modelFactory.createSelectSetResultSet(stmt);

                        ResultSet leftResultSetModel = (ResultSet) modelManager.getModel(stmt.getLeftStmt());
                        if (leftResultSetModel != null && leftResultSetModel != resultSet
                                        && !leftResultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                impactRelation.setEffectType(EffectType.select);
                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                leftResultSetModel.getRelationRows()));
                                impactRelation.setTarget(
                                                new RelationRowsRelationshipElement<ResultSetRelationRows>(resultSet.getRelationRows()));
                        }
                        
                        ResultSet rightResultSetModel = (ResultSet) modelManager.getModel(stmt.getRightStmt());
                        if (rightResultSetModel != null && rightResultSetModel != resultSet
                                        && !rightResultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                impactRelation.setEffectType(EffectType.select);
                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                rightResultSetModel.getRelationRows()));
                                impactRelation.setTarget(
                                                new RelationRowsRelationshipElement<ResultSetRelationRows>(resultSet.getRelationRows()));
                        }
                        
                        if ((leftResultSetModel != null && leftResultSetModel.isDetermined())
                                        || (rightResultSetModel != null && rightResultSetModel.isDetermined())) {
                                resultSet.setDetermined(true);
                        }
                        
                        if (resultSet.getColumns() == null || resultSet.getColumns().isEmpty()) {
                                if (getResultColumnList(stmt.getLeftStmt()) != null) {
                                        createSelectSetResultColumns(resultSet, stmt.getLeftStmt());
                                } else if (getResultColumnList(stmt.getRightStmt()) != null) {
                                        createSelectSetResultColumns(resultSet, stmt.getRightStmt());
                                }
                        }

                        List<ResultColumn> columns = resultSet.getColumns();
                        // a star of unknown width: each column reads the columns of each branch that can stand at its position
                        // (Mantis 4914)
                        List<List<List<ResultColumn>>> spanSources = setOperationSpanSources(stmt, columns);
                        // a star of the set operation names positions, and another branch's column may name one of them: such a
                        // name is no name of a branch's star, so the star's names are passed on to the stars of its branches only
                        // when every branch is one star of the same tables (Mantis 4974)
                        boolean passNames = spanSources != null && branchesReadTheSameTables(stmt);
                        for (int i = 0; i < columns.size(); i++) {
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.select);
                                relation.setTarget(new ResultColumnRelationshipElement(columns.get(i)));

                                if (spanSources != null) {
                                        List<ResultColumn> recorded = new ArrayList<ResultColumn>();
                                        for (List<List<ResultColumn>> branchSources : spanSources) {
                                                for (ResultColumn column : branchSources.get(i)) {
                                                        relation.addSource(new ResultColumnRelationshipElement(column), passNames);
                                                        recorded.add(column);
                                                }
                                        }
                                        setColumnSources.put(columns.get(i), recorded);
                                        continue;
                                }

                                if (!stmt.getLeftStmt().isCombinedQuery()) {
                                        ResultSet sourceResultSet = (ResultSet) modelManager
                                                        .getModel(stmt.getLeftStmt().getResultColumnList());
                                        if (sourceResultSet!=null && sourceResultSet.getColumns().size() > i) {
                                                if (columns.get(i).isStarColumn()) {
                                                        for (ResultColumn column : sourceResultSet.getColumns()) {
                                                                relation.addSource(new ResultColumnRelationshipElement(column));
                                                        }
                                                } else {
                                                        relation.addSource(
                                                                        new ResultColumnRelationshipElement(sourceResultSet.getColumns().get(i)));
                                                }
                                        }
                                } else {
                                        ResultSet sourceResultSet = (ResultSet) modelManager.getModel(stmt.getLeftStmt());
                                        if (sourceResultSet != null && sourceResultSet.getColumns().size() > i) {
                                                if (columns.get(i).isStarColumn()) {
                                                        for (ResultColumn column : sourceResultSet.getColumns()) {
                                                                relation.addSource(new ResultColumnRelationshipElement(column));
                                                        }
                                                } else {
                                                        relation.addSource(
                                                                        new ResultColumnRelationshipElement(sourceResultSet.getColumns().get(i)));
                                                }
                                        }
                                }

                                if (!stmt.getRightStmt().isCombinedQuery()) {
                                        ResultSet sourceResultSet = (ResultSet) modelManager
                                                        .getModel(stmt.getRightStmt().getResultColumnList());
                                        if (sourceResultSet != null && sourceResultSet.getColumns().size() > i) {
                                                if (columns.get(i).isStarColumn()) {
                                                        for (ResultColumn column : sourceResultSet.getColumns()) {
                                                                relation.addSource(new ResultColumnRelationshipElement(column));
                                                        }
                                                } else {
                                                        relation.addSource(
                                                                        new ResultColumnRelationshipElement(sourceResultSet.getColumns().get(i)));
                                                }
                                        } else if (sourceResultSet != null) {
                                                for (ResultColumn column : sourceResultSet.getColumns()) {
                                                        if (column.hasStarLinkColumn()) {
                                                                relation.addSource(new ResultColumnRelationshipElement(column));
                                                        }
                                                }
                                        }
                                } else {
                                        ResultSet sourceResultSet = (ResultSet) modelManager.getModel(stmt.getRightStmt());
                                        if (sourceResultSet != null && sourceResultSet.getColumns().size() > i) {
                                                relation.addSource(new ResultColumnRelationshipElement(sourceResultSet.getColumns().get(i)));
                                        } else if (sourceResultSet != null) {
                                                for (ResultColumn column : sourceResultSet.getColumns()) {
                                                        if (column.hasStarLinkColumn()) {
                                                                relation.addSource(new ResultColumnRelationshipElement(column));
                                                        }
                                                }
                                        }
                                }
                        }
                        
                        for (int i = 0; i < columns.size(); i++) {
                                // rule R8: the fields a branch's STRUCT has are fields of the set operation's column; a branch
                                // without them feeds the column itself, as above (plan acceptance row 26)
                                if (spanSources != null) {
                                        for (List<List<ResultColumn>> branchSources : spanSources) {
                                                if (branchSources.get(i).size() == 1 && !branchSources.get(i).get(0).isStarColumn()) {
                                                        setOperationFieldNodes(columns.get(i), branchSources.get(i).get(0));
                                                }
                                        }
                                        continue;
                                }
                                setOperationFieldNodes(columns.get(i), setOperationBranchColumn(stmt.getLeftStmt(), i));
                                setOperationFieldNodes(columns.get(i), setOperationBranchColumn(stmt.getRightStmt(), i));
                        }

                        analyzeSelectIntoClause(stmt);
                        
                        stmtStack.pop();
                } else {

                        // handle hive stmt, issue_id I3SGZB
                        if (stmt.getHiveBodyList() != null && stmt.getHiveBodyList().size() > 0) {
                                stmtStack.push(stmt);
                                hiveFromTables = stmt.tables;
                                if (hiveFromTables != null) {
                                        for (int i = 0; i < hiveFromTables.size(); i++) {
                                                if (hiveFromTables.getTable(i).getTableType() == ETableSource.lateralView) {
                                                        // one relation for every INSERT body, modelled with the first (analyzeLateralViewRelation)
                                                        continue;
                                                }
                                                modelFactory.createTable(hiveFromTables.getTable(i));
                                        }
                                }
                                for (int i = 0; i < stmt.getHiveBodyList().size(); i++) {
                                        analyzeCustomSqlStmt(stmt.getHiveBodyList().get(i));
                                }
                                stmtStack.pop();
                                return;
                        }
                        
                        if (stmt.getTransformClause() != null) {
                                analyzeHiveTransformClause(stmt, stmt.getTransformClause());
                                return;
                        }

                        if (stmt.getResultColumnList() == null) {
                                return;
                        }

                        stmtStack.push(stmt);

                        TTableList fromTables = stmt.tables;
                        if ((fromTables == null || fromTables.size() == 0)
                                        && (hiveFromTables != null && hiveFromTables.size() > 0)) {
                                fromTables = hiveFromTables;
                        }

                        for (int i = 0; i < fromTables.size(); i++) {
                                TTable table = fromTables.getTable(i);
                                if (table.getUnnestClause() != null && gudusoft.gsqlparser.nodes.structured.NestedAccessProfile
                                                .forVendor(option.getVendor()).usesPrestoUnnestPath()) {
                                        analyzeTableSubquery(table);
                                        analyzePrestoUnnest(stmt, table);
                                        stmtStack.pop();
                                        return;
                                }
                                if (table.getUnnestClause() != null && gudusoft.gsqlparser.nodes.structured.NestedAccessProfile
                                                .forVendor(option.getVendor()).getUnnestExpansion()
                                                == gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.UnnestExpansion.VALUE_TABLE) {
                                        analyzeBigQueryUnnest(stmt, table);
                                }
                        }
                        
                        //用来获取 pivotedTable 对应的columns
                        TPivotedTable pivotedTable = null; 
                        if (stmt.getJoins() != null && stmt.getJoins().size() > 0) {
                                for (TJoin join : stmt.getJoins()) {
                                        if (join.getTable() != null && join.getTable().getPivotedTable() != null) {
                                                if (isUnPivotedTable(join.getTable().getPivotedTable())) {
                                                        analyzeUnPivotedTable(stmt, join.getTable().getPivotedTable());
                                                        pivotedTable = join.getTable().getPivotedTable();
                                                } else {
                                                        analyzePivotedTable(stmt, join.getTable().getPivotedTable());
                                                        pivotedTable = join.getTable().getPivotedTable();
                                                }
                                        }
                                }
                        }

                        for (int i = 0; i < fromTables.size(); i++) {
                                TTable table = fromTables.getTable(i);
                                if (table.getTableType() == ETableSource.lateralView) {
                                        // modelled below, once every relation to its left is (analyzeLateralViewRelation)
                                        continue;
                                }
                                // Handle TABLE(func()) which has tableType=tableExpr and funcCall=null
                                if (table.getTableType() == ETableSource.tableExpr && table.getFuncCall() == null && pipelinedAnalyzer != null) {
                                        try {
                                                pipelinedAnalyzer.tryStitchTableExpr(table);
                                        } catch (Exception e) {
                                                // Don't let pipelined stitching failure break main flow
                                        }
                                }

                                if (table.getFuncCall() != null || (table.getTableExpr()!=null && table.getTableExpr().getFunctionCall()!=null)) {
                                        TFunctionCall functionCall = table.getFuncCall();
                                        if (functionCall == null) {
                                                functionCall = table.getTableExpr().getFunctionCall();
                                        }
                                        Procedure callee = modelManager.getProcedure(callAliasKey(functionCall));
                                        if (callee == null && analyzeProcedureDefinition(callAliasKey(functionCall))) {
                                                callee = modelManager.getProcedure(callAliasKey(functionCall));
                                        }

                                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("tableFunction", functionCall.getFunctionName(), callee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf(functionCall)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.FUNCTION);
                                        if(callee!=null) {
                                                if (callee.getArguments() != null) {
                                                        for (int j = 0; j < callee.getArguments().size(); j++) {
                                                                Argument argument = callee.getArguments().get(j);
                                                                Variable variable = resolveFormalVariable(callee, argument);
                                                                if(variable!=null) {
                                                                        if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                                                                Transform transform = new Transform();
                                                                                transform.setType(Transform.FUNCTION);
                                                                                transform.setCode(functionCall);
                                                                                compositeBindingColumn(variable).setTransform(transform);
                                                                        }
                                                                        Process process = modelFactory.createProcess(functionCall);
                                                                        variable.addProcess(process);
                                                                        analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), functionCall, j, process);
                                                                }
                                                        }
                                                }
                                                Set<Object> functionTableModelObjs = modelManager.getFunctionResults(nameAliasKey(functionCall.getFunctionName(), null));
                                                if (functionTableModelObjs != null) {
                                                        modelManager.bindModel(table, functionTableModelObjs.iterator().next());
                                                }
                                                // Try pipelined function stitching
                                                if (pipelinedAnalyzer != null) {
                                                        try {
                                                                pipelinedAnalyzer.tryStitchCallSite(table, functionCall);
                                                        } catch (Exception e) {
                                                                // Don't let pipelined stitching failure break main flow
                                                        }
                                                }
                                                continue;
                                        } else {
                                                Set<Object> functionTableModelObjs = modelManager.getFunctionResults(nameAliasKey(functionCall.getFunctionName(), null));
                                                if (functionTableModelObjs == null) {
                                                        // ClickHouse external table functions expose real
                                                        // external data; a generic function node silently
                                                        // dropped their upstream (missing lineage is
                                                        // invisible to the user — the correctness ruling).
                                                        if (modelClickhouseExternalTableFunction(table, functionCall)) {
                                                                continue;
                                                        }
//                                                      Procedure procedure = modelManager.getProcedureByName(DlineageUtil
//                                                                      .getIdentifierNormalTableName(functionCall.getFunctionName().toString()));
//                                                      if (procedure != null) {
                                                                createFunction(functionCall);
                                                                continue;
//                                                      }
                                                }
                                                if (functionTableModelObjs!=null && functionTableModelObjs.iterator().next() instanceof Table) {
                                                        Table functionTableModel = (Table) functionTableModelObjs.iterator().next();
                                                        if (functionTableModel.getColumns() != null) {
                                                                Table functionTable = modelFactory.createTableFromCreateDDL(table, true);
                                                                if (functionTable == functionTableModel)
                                                                        continue;
                                                                for (int j = 0; j < functionTableModel.getColumns().size(); j++) {
                                                                        TableColumn column = modelFactory.createTableColumn(functionTable,
                                                                                        functionTableModel.getColumns().get(j).getColumnObject(), true);
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new TableColumnRelationshipElement(column));
                                                                        relation.addSource(
                                                                                        new TableColumnRelationshipElement(functionTableModel.getColumns().get(j)));
                                                                }
                                                        }
                                                } else if (functionTableModelObjs!=null && functionTableModelObjs.iterator().next() instanceof ResultSet) {
                                                        ResultSet functionTableModel = (ResultSet) functionTableModelObjs.iterator().next();
                                                        if (functionTableModel.getColumns() != null) {
                                                                Table functionTable = modelFactory.createTableFromCreateDDL(table, true);
                                                                for (int j = 0; j < functionTableModel.getColumns().size(); j++) {
                                                                        TParseTreeNode columnObj = functionTableModel.getColumns().get(j).getColumnObject();
                                                                        if (columnObj instanceof TObjectName) {
                                                                                TableColumn column = modelFactory.createTableColumn(functionTable,
                                                                                                (TObjectName) columnObj, true);
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new TableColumnRelationshipElement(column));
                                                                                relation.addSource(new ResultColumnRelationshipElement(
                                                                                                functionTableModel.getColumns().get(j)));
                                                                        } else if (columnObj instanceof TResultColumn) {
                                                                                TableColumn column = modelFactory.createTableColumn(functionTable,
                                                                                                (TResultColumn) columnObj);
                                                                                if (column == null) {
                                                                                        // a function result column the table model cannot name (an
                                                                                        // unaliased expression): no relation instead of a null target
                                                                                        continue;
                                                                                }
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new TableColumnRelationshipElement(column));
                                                                                relation.addSource(new ResultColumnRelationshipElement(
                                                                                                functionTableModel.getColumns().get(j)));
                                                                        }
                                                                }
                                                        }
                                                }
                                                // Try pipelined function stitching for unresolved function calls
                                                if (pipelinedAnalyzer != null) {
                                                        try {
                                                                pipelinedAnalyzer.tryStitchCallSite(table, functionCall);
                                                        } catch (Exception e) {
                                                                // Don't let pipelined stitching failure break main flow
                                                        }
                                                }
                                        }
                                }

                                if (table.getPartitionExtensionClause() != null
                                                && table.getPartitionExtensionClause().getKeyValues() != null) {
                                        TExpressionList values = table.getPartitionExtensionClause().getKeyValues();
                                        Table tableModel = modelFactory.createTable(table);
                                        for (TExpression value : values) {
                                                if (value.getExpressionType() == EExpressionType.simple_constant_t) {
                                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                        impactRelation.setEffectType(EffectType.select);
                                                        Table constantTable = modelFactory.createConstantsTable(stmtStack.peek());
                                                        TableColumn constantColumn = modelFactory.createTableColumn(constantTable, value.getConstantOperand());
                                                        impactRelation.addSource(new TableColumnRelationshipElement(constantColumn));
                                                        impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                        tableModel.getRelationRows()));
                                                }
                                        }
                                }

                                if (table.getSubquery() != null) {
                                        QueryTable queryTable = modelFactory.createQueryTable(table);
                                        TSelectSqlStatement subquery = table.getSubquery();
                                        analyzeSelectStmt(subquery);

                                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(subquery);
                                        if (resultSetModel != null && resultSetModel.isDetermined()) {
                                                queryTable.setDetermined(true);
                                        }

                                        if (resultSetModel != null && resultSetModel != queryTable
                                                        && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(EffectType.select);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                resultSetModel.getRelationRows()));
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                queryTable.getRelationRows()));
                                        }

                                        // a set operation with a star of unknown width: each column of the alias list reads, from each
                                        // select, the items that can stand at its position (Mantis 4914)
                                        List<SelectPositions> setSelects = resultSetModel != null && resultSetModel != queryTable
                                                        && subquery.isCombinedQuery() && queryTable.getTableObject().getAliasClause() != null
                                                        && queryTable.getTableObject().getAliasClause().getColumns() != null
                                                        ? setOperationPositions(subquery, queryTable.getColumns().size(),
                                                                        shorterList(queryTable.getTableObject().getAliasClause().getColumns(),
                                                                                        queryTable.getTableObject())) : null;
                                        if (setSelects != null) {
                                                mapCteColumnsByCandidates(queryTable, setSelects,
                                                                queryTable.getTableObject().getAliasClause().getColumns());
                                        } else if (resultSetModel != null && resultSetModel != queryTable
                                                        && queryTable.getTableObject().getAliasClause() != null
                                                        && queryTable.getTableObject().getAliasClause().getColumns() != null) {
                                                int resultSetSize = resultSetModel.getColumns().size();
                                                ResultColumn lastColumn = resultSetSize == 0 ? null : resultSetModel.getColumns().get(resultSetSize - 1);
                                                // the names of FROM (SELECT * FROM t) d(a, b) past a star whose columns are not known are
                                                // columns of that star too (Mantis 4843)
                                                int aliasCount = lastColumn != null && lastColumn.isStarColumn()
                                                                ? queryTable.getTableObject().getAliasClause().getColumns().size() : resultSetSize;
                                                for (int j = 0; j < queryTable.getColumns().size()
                                                                && j < Math.max(resultSetSize, aliasCount); j++) {
                                                        ResultColumn sourceColumn = resultSetModel.getColumns().get(Math.min(j, resultSetSize - 1));
                                                        ResultColumn targetColumn = queryTable.getColumns().get(j);

                                                        DataFlowRelationship queryRalation = modelFactory.createDataFlowRelation();
                                                        queryRalation.setEffectType(EffectType.select);
                                                        queryRalation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                        queryRalation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                                }
                                                // FROM (SELECT c1, c2, c3 ...) d(a): a list shorter than the columns renames the first ones, the others
                                                // keep their names (PostgreSQL), in order (Mantis 4873). Past a star of unknown width no column has a
                                                // proven position, and a name the derived table already has is ambiguous: neither gets a column.
                                                int listed = queryTable.getTableObject().getAliasClause().getColumns().size();
                                                for (int j = 0; j < resultSetSize && !resultSetModel.getColumns().get(j).isStarColumn(); j++) {
                                                        ResultColumn sourceColumn = resultSetModel.getColumns().get(j);
                                                        if (j >= listed && !namedIn(queryTable, sourceColumn.getName())) {
                                                                derivedColumnPastList(queryTable, sourceColumn);
                                                        }
                                                }
                                        } else if (subquery.getSetOperatorType() != ESetOperatorType.none) {
                                                SelectSetResultSet selectSetResultSetModel = (SelectSetResultSet) modelManager
                                                                .getModel(subquery);
                                                for (int j = 0; j < selectSetResultSetModel.getColumns().size(); j++) {
                                                        ResultColumn sourceColumn = selectSetResultSetModel.getColumns().get(j);
                                                        ResultColumn targetColumn = modelFactory.createSelectSetResultColumn(queryTable,
                                                                        sourceColumn);
                                                        for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                targetColumn.bindStarLinkColumn(starLinkColumn);
                                                        }
                                                        DataFlowRelationship selectSetRalation = modelFactory.createDataFlowRelation();
                                                        selectSetRalation.setEffectType(EffectType.select);
                                                        selectSetRalation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                        selectSetRalation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                                }
                                        } else if (resultSetModel == null && subquery.getValueClause() != null) {
                                                analyzeValuesDerivedTable(queryTable, subquery.getValueClause());
                                        }
                                } else if (table.getOutputMerge() != null) {
                                        QueryTable queryTable = modelFactory.createQueryTable(table);
                                        TMergeSqlStatement subquery = table.getOutputMerge();
                                        analyzeMergeStmt(subquery);

                                        for (TResultColumn column : subquery.getOutputClause().getSelectItemList()) {
                                                modelFactory.createResultColumn(queryTable, column);
                                                analyzeResultColumn(column, EffectType.select);
                                        }

                                        ResultSet resultSetModel = (ResultSet) modelManager
                                                        .getModel(subquery.getOutputClause().getSelectItemList());

                                        if (resultSetModel != null && resultSetModel != queryTable
                                                        && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(EffectType.select);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                resultSetModel.getRelationRows()));
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                queryTable.getRelationRows()));
                                        }

                                        if (resultSetModel != null && resultSetModel != queryTable
                                                        && queryTable.getTableObject().getAliasClause() != null
                                                        && queryTable.getTableObject().getAliasClause().getColumns() != null) {
                                                for (int j = 0; j < queryTable.getColumns().size()
                                                                && j < resultSetModel.getColumns().size(); j++) {
                                                        ResultColumn sourceColumn = resultSetModel.getColumns().get(j);
                                                        ResultColumn targetColumn = queryTable.getColumns().get(j);

                                                        DataFlowRelationship queryRalation = modelFactory.createDataFlowRelation();
                                                        queryRalation.setEffectType(EffectType.select);
                                                        queryRalation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                        queryRalation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                                }
                                        }
                                } else if (table.getTableExpr() != null && table.getTableExpr().getSubQuery() != null) {
                                        QueryTable queryTable = modelFactory.createQueryTable(table);
                                        TSelectSqlStatement subquery = table.getTableExpr().getSubQuery();
                                        analyzeSelectStmt(subquery);

                                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(subquery);

                                        if (resultSetModel != null && resultSetModel != queryTable
                                                        && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(EffectType.select);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                resultSetModel.getRelationRows()));
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                queryTable.getRelationRows()));
                                        }

                                        if (resultSetModel != null && resultSetModel != queryTable
                                                        && queryTable.getTableObject().getAliasClause() != null) {
                                                for (int j = 0; j < resultSetModel.getColumns().size(); j++) {
                                                        ResultColumn sourceColumn = resultSetModel.getColumns().get(j);
                                                        ResultColumn targetColumn = modelFactory.createSelectSetResultColumn(queryTable,
                                                                        sourceColumn);

                                                        DataFlowRelationship queryRalation = modelFactory.createDataFlowRelation();
                                                        queryRalation.setEffectType(EffectType.select);
                                                        queryRalation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                        queryRalation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                                }
                                        } else if (subquery.getSetOperatorType() != ESetOperatorType.none) {
                                                SelectSetResultSet selectSetResultSetModel = (SelectSetResultSet) modelManager
                                                                .getModel(subquery);
                                                for (int j = 0; j < selectSetResultSetModel.getColumns().size(); j++) {
                                                        ResultColumn sourceColumn = selectSetResultSetModel.getColumns().get(j);
                                                        ResultColumn targetColumn = modelFactory.createSelectSetResultColumn(queryTable,
                                                                        sourceColumn);
                                                        for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                targetColumn.bindStarLinkColumn(starLinkColumn);
                                                        }
                                                        DataFlowRelationship selectSetRalation = modelFactory.createDataFlowRelation();
                                                        selectSetRalation.setEffectType(EffectType.select);
                                                        selectSetRalation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                        selectSetRalation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                                }
                                        }
                                } else if (table.getCTE() != null) {
                                        QueryTable queryTable = modelFactory.createQueryTable(table);

                                        TObjectNameList cteColumns = table.getCTE().getColumnList();
                                        if (cteColumns != null) {
                                                for (int j = 0; j < cteColumns.size(); j++) {
                                                        modelFactory.createResultColumn(queryTable, cteColumns.getObjectName(j));
                                                }
                                                queryTable.setDetermined(true);
                                        }
                                        TSelectSqlStatement subquery = table.getCTE().getSubquery();
                                        if (subquery != null && !stmtStack.contains(subquery) && subquery.getResultColumnList() != null) {
                                                analyzeSelectStmt(subquery);

                                                ResultSet resultSetModel = (ResultSet) modelManager.getModel(subquery);
                                                if (resultSetModel != null && resultSetModel != queryTable
                                                                && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                        impactRelation.setEffectType(EffectType.select);
                                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                        resultSetModel.getRelationRows()));
                                                        impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                        queryTable.getRelationRows()));
                                                }

                                                if (subquery.getSetOperatorType() != ESetOperatorType.none) {
                                                        SelectSetResultSet selectSetResultSetModel = (SelectSetResultSet) modelManager
                                                                        .getModel(subquery);
                                                        int x = 0;
                                                        boolean oneStar = starColumnCount(resultSetModel.getColumns()) == 1;
                                                        int cteItems = resultSetModel.getColumns().size();
                                                        // a star of unknown width in a select: each CTE column reads, from each select, the items that
                                                        // can stand at its position, as an INSERT column list does (Mantis 4914)
                                                        List<SelectPositions> setSelects = cteColumns == null ? null
                                                                        : setOperationPositions(subquery, queryTable.getColumns().size(),
                                                                                        shorterList(cteColumns, table));
                                                        if (setSelects != null) {
                                                                mapCteColumnsByCandidates(queryTable, setSelects, cteColumns);
                                                        }
                                                        for (int j = 0; setSelects == null && j < selectSetResultSetModel.getColumns().size(); j++) {
                                                                ResultColumn sourceColumn = selectSetResultSetModel.getColumns().get(j);
                                                                ResultColumn targetColumn = null;
                                                                if (cteColumns != null) {
                                                                        if (queryTable.getColumns().size() <= j) {
                                                                                for (int k = 0; k < queryTable.getColumns().size(); k++) {
                                                                                        if (queryTable.getColumns().get(k).getName().equals(sourceColumn.getName())
                                                                                                        || queryTable.getColumns().get(k).getName()
                                                                                                                        .equals(sourceColumn.getAlias())) {
                                                                                                targetColumn = queryTable.getColumns().get(k);
                                                                                        }
                                                                                }
                                                                        } else {
                                                                                if (x < j) {
                                                                                        x = j;
                                                                                }
                                                                                targetColumn = queryTable.getColumns().get(x);
                                                                                x++;
                                                                                // one star of unknown width takes the CTE columns the items after it leave
                                                                                if (resultSetModel.getColumns().get(j).isStarColumn() && (oneStar
                                                                                                ? cteColumns.size() - x > selectItemsFrom(resultSetModel.getColumns(), j + 1, cteItems)
                                                                                                : x < cteColumns.size())) {
                                                                                        j--;
                                                                                }
                                                                        }
                                                                } else {
                                                                        targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                                                }
                                                                for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                        targetColumn.bindStarLinkColumn(starLinkColumn);
                                                                }
                                                                createCteSelectRelation(null, targetColumn, sourceColumn, cteColumns != null);
                                                                if (targetColumn != null) {
                                                                        // the field nodes the column carries (rule R8, Codex review of phase 3)
                                                                        setOperationFieldNodes(targetColumn, sourceColumn);
                                                                }
                                                        }
                                                        if (!queryTable.isDetermined()) {
                                                                queryTable.setDetermined(selectSetResultSetModel.isDetermined());
                                                        }
                                                } else {
                                                        int x = 0;
                                                        int grouped = 0;
                                                        boolean oneStar = starColumnCount(resultSetModel.getColumns()) == 1;
                                                        int cteItems = resultSetModel.getColumns().size();
                                                        // two or more stars of unknown width leave the boundary between them unknown: each CTE column reads every
                                                        // select item that can stand at its position, as an INSERT column list does (Mantis 4916)
                                                        boolean byCandidates = cteColumns != null && starColumnCount(resultSetModel.getColumns()) > 1;
                                                        if (byCandidates) {
                                                                mapCteColumnsByCandidates(queryTable, Collections.singletonList(
                                                                                selectPositions(resultSetModel.getColumns(), queryTable.getColumns().size(),
                                                                                                shorterList(cteColumns, table))), cteColumns);
                                                        }
                                                        for (int j = 0; !byCandidates && j < resultSetModel.getColumns().size(); j++) {
                                                                ResultColumn sourceColumn = resultSetModel.getColumns().get(j);
                                                                ResultColumn targetColumn = null;
                                                                if (cteColumns != null && structFieldPaths.containsKey(sourceColumn)
                                                                                && Math.max(x, j - grouped) < queryTable.getColumns().size()) {
                                                                        // a select item that builds a STRUCT is one CTE column, all of its fields: whole
                                                                        // edges, and a field node per field (rule R8, Codex review of phase 3)
                                                                        int width = selectItemWidth(resultSetModel.getColumns(), j);
                                                                        targetColumn = queryTable.getColumns().get(Math.max(x, j - grouped));
                                                                        for (int k = j; k < j + width; k++) {
                                                                                ResultColumn field = resultSetModel.getColumns().get(k);
                                                                                createCteSelectRelation(null, targetColumn, field);
                                                                                StructFieldPath path = structFieldPaths.get(field);
                                                                                ResultColumn node = builtFieldNodeAt(targetColumn, path.path);
                                                                                if (node == null) {
                                                                                        node = structFieldNode(targetColumn, path.path,
                                                                                                        cteColumns.getObjectName(Math.max(x, j - grouped)), path.item);
                                                                                }
                                                                                DataFlowRelationship nodeRelation = modelFactory.createDataFlowRelation();
                                                                                nodeRelation.setEffectType(EffectType.select);
                                                                                nodeRelation.setTarget(new ResultColumnRelationshipElement(node));
                                                                                nodeRelation.addSource(new ResultColumnRelationshipElement(field));
                                                                        }
                                                                        x = Math.max(x, j - grouped) + 1;
                                                                        grouped += width - 1;
                                                                        j += width - 1;
                                                                        continue;
                                                                }
                                                                if (cteColumns != null) {
                                                                        if (queryTable.getColumns().size() <= j - grouped) {
                                                                                for (int k = 0; k < queryTable.getColumns().size(); k++) {
                                                                                        if (queryTable.getColumns().get(k).getName().equals(sourceColumn.getName())
                                                                                                        || queryTable.getColumns().get(k).getName()
                                                                                                                        .equals(sourceColumn.getAlias())) {
                                                                                                targetColumn = queryTable.getColumns().get(k);
                                                                                        }
                                                                                }
                                                                        } else {
                                                                                if (x < j - grouped) {
                                                                                        x = j - grouped;
                                                                                }
                                                                                targetColumn = queryTable.getColumns().get(x);
                                                                                x++;
                                                                                // one star of unknown width takes the CTE columns the items after it leave, a
                                                                                // STRUCT item one of them (rule R8, owner ruling 2026-10-07); two or more
                                                                                // leave the boundary between them unknown and keep the old greedy pairing
                                                                                if (resultSetModel.getColumns().get(j).isStarColumn() && (oneStar
                                                                                                ? cteColumns.size() - x > selectItemsFrom(resultSetModel.getColumns(), j + 1, cteItems)
                                                                                                : x < cteColumns.size())) {
                                                                                        j--;
                                                                                }
                                                                        }
                                                                } else {
                                                                        targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                                                }
                                                                for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                        targetColumn.bindStarLinkColumn(starLinkColumn);
                                                                }
                                                                createCteSelectRelation(null, targetColumn, sourceColumn, cteColumns != null);
                                                                if (targetColumn != null) {
                                                                        // the field nodes the column carries (rule R8, Codex review of phase 3)
                                                                        setOperationFieldNodes(targetColumn, sourceColumn);
                                                                }
                                                        }
                                                        if (!queryTable.isDetermined()) {
                                                                queryTable.setDetermined(resultSetModel.isDetermined());
                                                        }
                                                }
                                        } else if (subquery != null && !stmtStack.contains(subquery) && subquery.getValueClause() != null) {
                                                // a CTE defined by VALUES: its rows feed its columns, as an UPDATE reading it does (Mantis 5010).
                                                // Since the CTE list of WITH ... VALUES is kept (Mantis 5017) a query can bind to such a CTE.
                                                analyzeValuesCte(queryTable, subquery.getValueClause(), cteColumns, null);
                                        } else if (table.getCTE().getUpdateStmt() != null) {
                                                analyzeCustomSqlStmt(table.getCTE().getUpdateStmt());
                                        } else if (table.getCTE().getInsertStmt() != null) {
                                                analyzeCustomSqlStmt(table.getCTE().getInsertStmt());
                                        } else if (table.getCTE().getDeleteStmt() != null) {
                                                analyzeCustomSqlStmt(table.getCTE().getDeleteStmt());
                                        } else if (table.getCTE().getMergeStmt() != null) {
                                                analyzeCustomSqlStmt(table.getCTE().getMergeStmt());
                                        }
                                } else if (table.getTableType().name().startsWith("open")) {
                                        continue;
                                } else if (table.getTableType() == ETableSource.jsonTable) {
                                        Table functionTable = modelFactory.createJsonTable(table);
                                        TJsonTable jsonTable = table.getJsonTable();
                                        TColumnDefinitionList definitions = jsonTable.getColumnDefinitions();
                                        if (definitions != null) {
                                                for (int j = 0; j < definitions.size(); j++) {
                            TColumnDefinitionList nestDefinitions = definitions.getColumn(j).getNestedTableColumns();
                                                        if(nestDefinitions!=null) {
                                                                for(int k=0;k<nestDefinitions.size();k++){
                                                                        if (nestDefinitions.getColumn(k).getColumnName() == null) {
                                                                                continue;
                                                                        }
                                                                        TableColumn column = modelFactory.createTableColumn(functionTable,
                                            nestDefinitions.getColumn(k).getColumnName(), true);
                                    if (nestDefinitions.getColumn(k).getColumnPath() != null) {
                                        column.setDisplayName(
                                                column.getName() + ":" + nestDefinitions.getColumn(k).getColumnPath());
                                    }
                                                                }
                                                        }
                                                        else {
                                TableColumn column = modelFactory.createTableColumn(functionTable,
                                        definitions.getColumn(j).getColumnName(), true);
                                if (definitions.getColumn(j).getColumnPath() != null) {
                                    column.setDisplayName(
                                            column.getName() + ":" + definitions.getColumn(j).getColumnPath());
                                }
                            }
                                                }
                                        } else {
                                                TObjectName keyColumn = new TObjectName();
                                                keyColumn.setString("key");
                                                modelFactory.createJsonTableColumn(functionTable, keyColumn);
                                                TObjectName valueColumn = new TObjectName();
                                                valueColumn.setString("value");
                                                modelFactory.createJsonTableColumn(functionTable, valueColumn);
                                                TObjectName typeColumn = new TObjectName();
                                                typeColumn.setString("type");
                                                modelFactory.createJsonTableColumn(functionTable, typeColumn);
                                        }

                                        functionTable.setCreateTable(true);
                                        functionTable.setSubType(SubType.function);
                                        modelManager.bindCreateModel(table, functionTable);

                                        if (jsonTable.getJsonExpression() == null) {
                                                ErrorInfo errorInfo = new ErrorInfo();
                                                errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                                                errorInfo.setErrorMessage("Can't handle the json table: " + jsonTable.toString());
                                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(jsonTable.getStartToken().lineNo,
                                                                jsonTable.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(jsonTable.getEndToken().lineNo,
                                                                jsonTable.getEndToken().columnNo + jsonTable.getEndToken().getAstext().length(),
                                                                ModelBindingManager.getGlobalHash()));
                                                errorInfo.fillInfo(this);
                                                errorInfos.add(errorInfo);
                                        } else {
                                                String jsonName = jsonTable.getJsonExpression().toString();
                                                if (!jsonName.startsWith("@")) {
                                                        columnsInExpr visitor = new columnsInExpr();
                                                        jsonTable.getJsonExpression().inOrderTraverse(visitor);
                                                        List<TObjectName> objectNames = visitor.getObjectNames();
                                                        List<TParseTreeNode> functions = visitor.getFunctions();
                                                        List<TParseTreeNode> constants = visitor.getConstants();
                                                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                                        for (int j = 0; j < functionTable.getColumns().size(); j++) {
                                                                TableColumn tableColumn = functionTable.getColumns().get(j);
                                                                if (functions != null && !functions.isEmpty()) {
                                                                        analyzeFunctionDataFlowRelation(tableColumn, functions, EffectType.function);
                                                                }
                                                                if (subquerys != null && !subquerys.isEmpty()) {
                                                                        analyzeSubqueryDataFlowRelation(tableColumn, subquerys, EffectType.select);
                                                                }
                                                                if (objectNames != null && !objectNames.isEmpty()) {
                                                                        analyzeDataFlowRelation(tableColumn, objectNames, EffectType.select, functions);
                                                                }
                                                                if (constants != null && !constants.isEmpty()) {
                                                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select,
                                                                                        functions);
                                                                }
                                                        }
                                                } else {
                                                        TStatementList stmts = stmt.getGsqlparser().getSqlstatements();
                                                        for (int j = 0; j < stmts.size(); j++) {
                                                                TCustomSqlStatement item = stmts.get(j);
                                                                if (item instanceof TMssqlDeclare) {
                                                                        if (analyzeMssqlJsonDeclare((TMssqlDeclare) item, jsonName, functionTable)) {
                                                                                break;
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                } else if (table.getTableType() == ETableSource.xmltable) {
                                        Table functionTable = modelFactory.createXmlTable(table);
                                        TXmlTable xmlTable = table.getXmlTable();
                                        TXmlTableParameter param = xmlTable != null ? xmlTable.getArg() : null;

                                        // Output columns from COLUMNS clause
                                        if (param != null && param.getXmlTableColumns() != null) {
                                                TColumnDefinitionList defs = param.getXmlTableColumns();
                                                for (int j = 0; j < defs.size(); j++) {
                                                        TColumnDefinition def = defs.getColumn(j);
                                                        TableColumn column = modelFactory.createTableColumn(
                                                                        functionTable, def.getColumnName(), true);
                                                        if (def.getXmlTableColumnPath() != null) {
                                                                column.setDisplayName(
                                                                                column.getName() + ":" + def.getXmlTableColumnPath());
                                                        }
                                                }
                                        }
                                        functionTable.setCreateTable(true);
                                        functionTable.setSubType(SubType.function);
                                        modelManager.bindCreateModel(table, functionTable);

                                        // Source columns from PASSING (v1: many-to-many)
                                        TResultColumnList passing = null;
                                        if (param != null && param.getXmlPassingClause() != null) {
                                                passing = param.getXmlPassingClause().getPassingList();
                                        }
                                        if (passing != null && passing.size() > 0) {
                                                columnsInExpr visitor = new columnsInExpr();
                                                for (int p = 0; p < passing.size(); p++) {
                                                        TExpression e = passing.getResultColumn(p).getExpr();
                                                        if (e != null) e.inOrderTraverse(visitor);
                                                }
                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                List<TParseTreeNode> functions = visitor.getFunctions();
                                                List<TParseTreeNode> constants = visitor.getConstants();
                                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                                for (int j = 0; j < functionTable.getColumns().size(); j++) {
                                                        TableColumn tc = functionTable.getColumns().get(j);
                                                        if (functions != null && !functions.isEmpty())
                                                                analyzeFunctionDataFlowRelation(tc, functions, EffectType.function);
                                                        if (subquerys != null && !subquerys.isEmpty())
                                                                analyzeSubqueryDataFlowRelation(tc, subquerys, EffectType.select);
                                                        if (objectNames != null && !objectNames.isEmpty())
                                                                analyzeDataFlowRelation(tc, objectNames, EffectType.select, functions);
                                                        if (constants != null && !constants.isEmpty())
                                                                analyzeConstantDataFlowRelation(tc, constants, EffectType.select, functions);
                                                }
                                        } else {
                                                ErrorInfo errorInfo = new ErrorInfo();
                                                errorInfo.setErrorType(ErrorInfo.ANALYZE_ERROR);
                                                errorInfo.setErrorMessage("Can't analyze XMLTABLE: missing PASSING clause.");
                                                errorInfos.add(errorInfo);
                                        }
                                } else if (getTableLinkedColumns(table) != null && getTableLinkedColumns(table).size() > 0) {
                                        if (table.getTableType() == ETableSource.rowList && table.getRowList() != null
                                                        && table.getRowList().size() > 0) {
                                                Table tableModel = modelFactory.createTable(table);
                                                for (int j = 0; j < table.getRowList().size(); j++) {
                                                        TMultiTarget rowList = table.getRowList().getMultiTarget(j);
                                                        for (int k = 0; k < rowList.getColumnList().size(); k++) {
                                                                TResultColumn column = rowList.getColumnList().getResultColumn(k);
                                                                if (column.getFieldAttr() == null)
                                                                        continue;
                                                                TableColumn tableColumn = modelFactory.createTableColumn(tableModel,
                                                                                column.getFieldAttr(), true);

                                                                columnsInExpr visitor = new columnsInExpr();
                                                                column.getExpr().inOrderTraverse(visitor);
                                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                                List<TParseTreeNode> functions = visitor.getFunctions();
                                                                List<TParseTreeNode> constants = visitor.getConstants();
                                                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();

                                                                if (functions != null && !functions.isEmpty()) {
                                                                        analyzeFunctionDataFlowRelation(tableColumn, functions, EffectType.function);
                                                                }
                                                                if (subquerys != null && !subquerys.isEmpty()) {
                                                                        analyzeSubqueryDataFlowRelation(tableColumn, subquerys, EffectType.select);
                                                                }
                                                                if (objectNames != null && !objectNames.isEmpty()) {
                                                                        analyzeDataFlowRelation(tableColumn, objectNames, EffectType.select, functions);
                                                                }
                                                                if (constants != null && !constants.isEmpty()) {
                                                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select,
                                                                                        functions);
                                                                }
                                                        }
                                                }
                                        } else {
                                                if(table.getTableType() == ETableSource.pivoted_table) {
                                                        continue;
                                                }
                                                if (table.getTableType() == ETableSource.rowList) {
                                                        List<TResultColumnList> rowList = table.getValueClause().getRows();
                                                        
                                                        QueryTable tableModel = modelFactory.createQueryTable(table);
                                                        TAliasClause aliasClause = table.getAliasClause();
                                                        if (aliasClause != null && aliasClause.getColumns() != null) {
                                                                for (TObjectName column : aliasClause.getColumns()) {
                                                                        modelFactory.createResultColumn(tableModel, column, true);
                                                                }       
                                                        } else {        
                                                                int columnCount = rowList.get(0).size();
                                                                for (int j = 1; j <= columnCount; j++) {
                                                                        TObjectName columnName = new TObjectName();
                                                                        // the vendor's name for the column (Mantis 4823), column<j> where no rule is known
                                                                        String name = TValueClause.defaultColumnName(option.getVendor(), j);
                                                                        columnName.setString(name != null ? name : "column" + j);
                                                                        modelFactory.createResultColumn(tableModel, columnName, true);
                                                                }
                                                        }
                                                        tableModel.setDetermined(true);
                                                        
                                                        for (TResultColumnList resultColumnList : rowList) {
                                                                for (int j = 0; j < resultColumnList.size(); j++) {
                                                                        TResultColumn resultColumn = resultColumnList.getResultColumn(j);
                                                                        analyzeValueColumn(tableModel.getColumns().get(j), resultColumn, EffectType.select);
                                                                }
                                                        }
                                                        
                                                } else {
                                                        Table tableModel = modelFactory.createTable(table);
                                                        for (int j = 0; j < getTableLinkedColumns(table).size(); j++) {
                                                                TObjectName object = getTableLinkedColumns(table).getObjectName(j);

                                                                if (object.getDbObjectType() == EDbObjectType.variable) {
                                                                        continue;
                                                                }

                                                                if (object.getColumnNameOnly().startsWith("@")
                                                                                && (option.getVendor() == EDbVendor.dbvmssql
                                                                                                || option.getVendor() == EDbVendor.dbvazuresql)) {
                                                                        continue;
                                                                }

                                                                if (object.getColumnNameOnly().startsWith(":")
                                                                                && (option.getVendor() == EDbVendor.dbvhana
                                                                                                || option.getVendor() == EDbVendor.dbvteradata)) {
                                                                        continue;
                                                                }

                                                                if (isBuiltInFunctionName(object) && isFromFunction(object)) {
                                                                        continue;
                                                                }

                                                                if (!DlineageUtil.isStarName((object))) {
                                                                        if (isStructColumn(object)) {

                                                                        } else {
                                                                                if (pivotedTable != null) {
                                                                                        ResultColumn resultColumn = getPivotedTableColumn(pivotedTable, object);
                                                                                        if (resultColumn != null) {
                                                                                                continue;
                                                                                        }
                                                                                }
                                                                                TableColumn tableColumn = modelFactory.createTableColumn(tableModel, object,
                                                                                                false);
                                                                                if(tableColumn == null) {
                                                                                        continue;
                                                                                }
                                                                                if (table.getUnnestClause() != null
                                                                                                && table.getUnnestClause().getArrayExpr() != null) {
                                                                                        columnsInExpr visitor = new columnsInExpr();
                                                                                        table.getUnnestClause().getArrayExpr().inOrderTraverse(visitor);

                                                                                        List<TObjectName> objectNames = visitor.getObjectNames();
                                                                                        List<TParseTreeNode> functions = visitor.getFunctions();

                                                                                        if (functions != null && !functions.isEmpty()) {
                                                                                                analyzeFunctionDataFlowRelation(tableColumn, functions,
                                                                                                                EffectType.select);

                                                                                        }

                                                                                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                                                                        if (subquerys != null && !subquerys.isEmpty()) {
                                                                                                analyzeSubqueryDataFlowRelation(tableColumn, subquerys,
                                                                                                                EffectType.select);
                                                                                        }

                                                                                        analyzeDataFlowRelation(tableColumn, objectNames, EffectType.select,
                                                                                                        functions);

                                                                                        List<TParseTreeNode> constants = visitor.getConstants();
                                                                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select,
                                                                                                        functions);
                                                                                }
                                                                        }
                                                                } else {
                                                                        boolean flag = false;
                                                                        for (TObjectName column : getTableLinkedColumns(table)) {
                                                                                if (DlineageUtil.isStarName((column))) {
                                                                                        continue;
                                                                                }
                                                                                if (column.getLocation() != ESqlClause.where
                                                                                                && column.getLocation() != ESqlClause.joinCondition) {
                                                                                        flag = true;
                                                                                }
                                                                        }
                                                                        if (!flag) {
                                                                                TableColumn tableColumn = modelFactory.createTableColumn(tableModel, object,
                                                                                                false);
                                                                                if (tableColumn != null && !tableModel.hasSQLEnv()) {
                                                                                        tableColumn.setShowStar(true);
                                                                                }
                                                                        }
                                                                }

                                                        }
                                                }
                                        }
                                }
                                else {
                                        modelFactory.createTable(table);
                                }
                        }

                        // plan section 4.3: a Hive-family LATERAL VIEW is one more relation of the FROM clause, modelled in FROM order
                        // so a view reads the relations to its left, an earlier view included (Mantis 4887-4890)
                        for (int i = 0; i < fromTables.size(); i++) {
                                if (fromTables.getTable(i).getTableType() == ETableSource.lateralView) {
                                        analyzeLateralViewRelation(fromTables.getTable(i));
                                }
                        }

                        gudusoft.gsqlparser.nodes.structured.NestedAccessProfile unnestProfile =
                                        gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(option.getVendor());
                        if (unnestProfile.getUnnestExpansion()
                                        == gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.UnnestExpansion.POSITIONAL_EXPANSION
                                        && !unnestProfile.usesPrestoUnnestPath()) {
                                // every FROM item is modelled now, so an UNNEST argument finds its owner's columns, be it a CTE, a derived
                                // table or a physical table; joins, filters and the select list stay with the general flow (Mantis 4826)
                                for (int i = 0; i < fromTables.size(); i++) {
                                        if (fromTables.getTable(i).getUnnestClause() != null) {
                                                analyzeTrinoUnnest(fromTables.getTable(i));
                                        }
                                }
                        }

                        if (pivotedTable!=null) {
                                for (TJoin join : stmt.getJoins()) {
                                        if (join.getTable() != null && join.getTable().getPivotedTable() != null) {
                                                if (isUnPivotedTable(join.getTable().getPivotedTable())) {
                                                        analyzeUnPivotedTable(stmt, join.getTable().getPivotedTable());
                                                } else {
                                                        analyzePivotedTable(stmt, join.getTable().getPivotedTable());
                                                }
                                                stmtStack.pop();
                                                return;
                                        }
                                }
                        }

                        if (!stmt.isCombinedQuery()) {
                                Object queryModel = modelManager.getModel(stmt.getResultColumnList());

                                if (queryModel == null) {
                                        TSelectSqlStatement parentStmt = getParentSetSelectStmt(stmt);
                                        if (isTopResultSet(stmt) || parentStmt == null) {
                                                ResultSet resultSetModel = modelFactory.createResultSet(stmt,
                                                                isTopResultSet(stmt) && isShowTopSelectResultSet() && stmt.getIntoClause() == null);

                                                createPseudoImpactRelation(stmt, resultSetModel, EffectType.select);

                                                boolean isDetermined = true;
                                                Map<String, AtomicInteger> keyMap = new HashMap<String, AtomicInteger>();
                                                Set<Object> columnIdentities = new HashSet<>();
                                                Set<String> columnNames = new HashSet<String>();
                                                // the source tables that published each column identity, for JOIN ... USING merging
                                                Map<Object, List<TTable>> tablesByIdentity = new HashMap<Object, List<TTable>>();
                                                for (int i = 0; i < stmt.getResultColumnList().size(); i++) {
                                                        TResultColumn column = stmt.getResultColumnList().getResultColumn(i);

                                                        if (column.getExpr().getComparisonType() == EComparisonType.equals
                                                                        && column.getExpr().getLeftOperand().getObjectOperand() != null) {
                                                                TObjectName columnObject = column.getExpr().getLeftOperand().getObjectOperand();

                                                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel,
                                                                                columnObject);
                                                                if (columnObject.getDbObjectType() == EDbObjectType.variable) {
                                                                        Table variable = modelManager.visibleLocal(columnObject.toString(),
                                                                                        LocalSymbolKey.Kind.VARIABLE);
                                                                        if (variable != null) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                TableColumn columnModel = variable instanceof Variable
                                                                                                ? compositeBindingColumn((Variable) variable)
                                                                                                : variable.getColumns().get(0);
                                                                                relation.setTarget(new TableColumnRelationshipElement(columnModel));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        } else {
                                                                                variable = modelFactory.createReferencedVariable(columnObject);
                                                                                variable.setCreateTable(true);
                                                                                variable.setSubType(SubType.record);
                                                                                TObjectName variableProperties = DlineageUtil.syntheticStarName();
                                                                                TableColumn variableProperty = modelFactory.createTableColumn(variable,
                                                                                                variableProperties, true);
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new TableColumnRelationshipElement(variableProperty));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        }
                                                                }

                                                                columnsInExpr visitor = new columnsInExpr();
                                                                column.getExpr().getRightOperand().inOrderTraverse(visitor);

                                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                                List<TParseTreeNode> functions = visitor.getFunctions();

                                                                if (functions != null && !functions.isEmpty()) {
                                                                        analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.select);

                                                                }

                                                                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                                                if (subquerys != null && !subquerys.isEmpty()) {
                                                                        analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.select);
                                                                }

                                                                analyzeDataFlowRelation(resultColumn, objectNames, EffectType.select, functions);

                                                                List<TParseTreeNode> constants = visitor.getConstants();
                                                                analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.select, functions);
                                                        } else {
                                                                if (column.getFieldAttr() != null && isStructColumn(column.getFieldAttr())) {
                                                                        Table table = modelFactory.createTable(column.getFieldAttr().getSourceTable());
                                                                        for (int j = 0; j < table.getColumns().size(); j++) {
                                                                                TObjectName columnName = new TObjectName();
                                                                                if (table.getColumns().get(j).getName().equals(table.getAlias())) {
                                                                                        if (!SQLUtil.isEmpty(column.getColumnAlias())) {
                                                                                                columnName.setString(column.getColumnAlias());
                                                                                        } else {
                                                                                                columnName.setString(table.getColumns().get(j).getName());
                                                                                        }
                                                                                } else {
                                                                                        columnName.setString(
                                                                                                        table.getAlias() + "." + table.getColumns().get(j).getName());
                                                                                }
                                                                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel,
                                                                                                columnName);
                                                                                DataFlowRelationship relationship = modelFactory.createDataFlowRelation();
                                                                                relationship.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relationship.addSource(
                                                                                                new TableColumnRelationshipElement(table.getColumns().get(j)));
                                                                        }
                                                                } else if (buildsStructItem(column)) {
                                                                        analyzeStructItem(resultSetModel, column);
                                                                } else if (column.getExpr().getFunctionCall() != null && column.getExpr().getFunctionCall().getFunctionType() == EFunctionType.array_t) {
                                                                        Function function = (Function) createFunction(column.getExpr().getFunctionCall());
                                                                        String functionName = getResultSetName(function);
                                                                        if (function.getColumns().size() == 1) {
                                                                                // Scalar result inside ARRAY() - use just alias as column name
                                                                                TObjectName columnName = new TObjectName();
                                                                                if (column.getAliasClause() != null) {
                                                                                        columnName.setString(column.getAliasClause().toString());
                                                                                } else {
                                                                                        columnName.setString(functionName);
                                                                                }
                                                                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel,
                                                                                                columnName);
                                                                                DataFlowRelationship relationship = modelFactory.createDataFlowRelation();
                                                                                relationship.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relationship.addSource(
                                                                                                new ResultColumnRelationshipElement(function.getColumns().get(0)));
                                                                        } else {
                                                                                for (int j = 0; j < function.getColumns().size(); j++) {
                                                                                        TObjectName columnName = new TObjectName();
                                                                                        if (column.getAliasClause() != null) {
                                                                                                columnName.setString(column.getAliasClause() + "."
                                                                                                                + getColumnNameOnly(function.getColumns().get(j).getName()));
                                                                                        }
                                                                                        else {
                                                                                                columnName.setString(functionName + "."
                                                                                                                + getColumnNameOnly(function.getColumns().get(j).getName()));
                                                                                        }
                                                                                        ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel,
                                                                                                        columnName);
                                                                                        resultColumn.setStruct(true);
                                                                                        DataFlowRelationship relationship = modelFactory.createDataFlowRelation();
                                                                                        relationship.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                        relationship.addSource(
                                                                                                        new ResultColumnRelationshipElement(function.getColumns().get(j)));
                                                                                }
                                                                        }
                                                                } else if (column.getExpr().getExprList() != null && column.getExpr().getExpressionType() == EExpressionType.array_t) {
                                                                        if(column.getExpr().getObjectOperand()!=null) {
                                                                                TObjectName exprColumnName = column.getExpr().getObjectOperand();
                                                                                Table table = modelFactory.createTable(exprColumnName.getSourceTable());
                                                                                List<TableColumn> arraySources = arrayItemSources(table, exprColumnName);
                                                                                for (int z = 0; z < arraySources.size(); z++) {
                                                                                        TableColumn tableColumn = arraySources.get(z);
                                                                                        {
                                                                                                TObjectName columnName = new TObjectName();
                                                                                                if (column.getAliasClause() != null) {
                                                                                                        columnName.setString(column.getAliasClause().toString());
                                                                                                } else {
                                                                                                        // BigQuery names an unaliased items[OFFSET(0)].item_name after its last
                                                                                                        // field, and items[OFFSET(0)] after the column; the empty name read here
                                                                                                        // threw NullPointerException (Mantis 4833)
                                                                                                        columnName.setString(unaliasedArrayItemName(exprColumnName));
                                                                                                }
                                                                                                ResultColumn resultColumn = modelFactory
                                                                                                                .createResultColumn(resultSetModel, columnName);
                                                                                                resultColumn.setStruct(true);
                                                                                                DataFlowRelationship relationship = modelFactory
                                                                                                                .createDataFlowRelation();
                                                                                                relationship.setTarget(
                                                                                                                new ResultColumnRelationshipElement(resultColumn));
                                                                                                relationship.addSource(new TableColumnRelationshipElement(
                                                                                                                tableColumn));
                                                                                        }
                                                                                }
                                                                        }
                                                                        else {
                                                                                for (int j = 0; j < column.getExpr().getExprList().size(); j++) {
                                                                                        TExpression expression = column.getExpr().getExprList().getExpression(j);
                                                                                        if(expression.getExpressionType() == EExpressionType.function_t) {
                                                                                                Function function = (Function)createFunction(expression.getFunctionCall());
                                                                                                String functionName = getResultSetName(function);
                                                                                                if (function != null && function.getColumns() != null) {
                                                                                                        if (function.getColumns().size() == 1) {
                                                                                                                // Scalar function inside ARRAY[] (e.g., ARRAY[TO_JSON_STRING(col)])
                                                                                                                // Use just the alias as column name, not alias.functionName
                                                                                                                TObjectName columnName = new TObjectName();
                                                                                                                if (column.getAliasClause() != null) {
                                                                                                                        columnName.setString(column.getAliasClause().toString());
                                                                                                                } else {
                                                                                                                        columnName.setString(functionName);
                                                                                                                }
                                                                                                                ResultColumn resultColumn = modelFactory
                                                                                                                                .createResultColumn(resultSetModel, columnName);
                                                                                                                DataFlowRelationship relationship = modelFactory
                                                                                                                                .createDataFlowRelation();
                                                                                                                relationship.setTarget(
                                                                                                                                new ResultColumnRelationshipElement(resultColumn));
                                                                                                                relationship.addSource(new ResultColumnRelationshipElement(
                                                                                                                                function.getColumns().get(0)));
                                                                                                        } else {
                                                                                                                // Multi-column (struct-like) function - use dotted naming
                                                                                                                for (int x = 0; x < function.getColumns().size(); x++) {
                                                                                                                        TObjectName columnName = new TObjectName();
                                                                                                                        if (column.getAliasClause() != null) {
                                                                                                                                columnName.setString(column.getAliasClause() + "."
                                                                                                                                                + getColumnNameOnly(
                                                                                                                                                function.getColumns().get(x).getName()));
                                                                                                                        } else {
                                                                                                                                columnName.setString(
                                                                                                                                                functionName + "." + getColumnNameOnly(
                                                                                                                                                                function.getColumns().get(x).getName()));
                                                                                                                        }
                                                                                                                        ResultColumn resultColumn = modelFactory
                                                                                                                                        .createResultColumn(resultSetModel, columnName);
                                                                                                                        resultColumn.setStruct(true);
                                                                                                                        DataFlowRelationship relationship = modelFactory
                                                                                                                                        .createDataFlowRelation();
                                                                                                                        relationship.setTarget(
                                                                                                                                        new ResultColumnRelationshipElement(resultColumn));
                                                                                                                        relationship.addSource(new ResultColumnRelationshipElement(
                                                                                                                                        function.getColumns().get(x)));
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                        else if(expression.getExpressionType() == EExpressionType.simple_object_name_t) {
                                                                                                TObjectName exprColumnName = expression.getObjectOperand();
                                                                                                Table table = modelFactory.createTable(exprColumnName.getSourceTable());
                                                                                                List<TableColumn> arraySources = arrayItemSources(table, exprColumnName);
                                                                                                for (int z = 0; z < arraySources.size(); z++) {
                                                                                                        TableColumn tableColumn = arraySources.get(z);
                                                                                                        {
                                                                                                                TObjectName columnName = new TObjectName();
                                                                                                                if (column.getAliasClause() != null) {
                                                                                                                        columnName.setString(column.getAliasClause().toString());
                                                                                                                } else {
                                                                                                                        columnName
                                                                                                                                        .setString(getColumnNameOnly(columnName.toString()));
                                                                                                                }
                                                                                                                ResultColumn resultColumn = modelFactory
                                                                                                                                .createResultColumn(resultSetModel, columnName);
                                                                                                                resultColumn.setStruct(true);
                                                                                                                DataFlowRelationship relationship = modelFactory
                                                                                                                                .createDataFlowRelation();
                                                                                                                relationship.setTarget(
                                                                                                                                new ResultColumnRelationshipElement(resultColumn));
                                                                                                                relationship.addSource(new TableColumnRelationshipElement(
                                                                                                                                tableColumn));
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                } else {
                                                                        if (propagateStructItem(resultSetModel, column)) {
                                                                                // a projection of a STRUCT a CTE or derived table built keeps its fields
                                                                                // (rule R8, Mantis 4893)
                                                                                continue;
                                                                        }
                                                                        Boolean structStar = analyzeStructStar(resultSetModel, column);
                                                                        if (structStar != null) {
                                                                                if (!structStar) {
                                                                                        isDetermined = false;
                                                                                }
                                                                                continue;
                                                                        }
                                                                        if (isStarItem(column)) {
                                                                                Map<String, Pair<String, TExpression>> replaceAsIdentifierMap = new HashMap<String, Pair<String, TExpression>>();
                                                                                Map<String, TObjectName> replaceColumnMap = new HashMap<String, TObjectName>();
                                                                                if(column.getReplaceExprAsIdentifiers()!=null && column.getReplaceExprAsIdentifiers().size()>0) {
                                                                                        for(TReplaceExprAsIdentifier replace: column.getReplaceExprAsIdentifiers()) {
                                                                                                replaceAsIdentifierMap.put(replace.getIdentifier().toString(), new Pair<String, TExpression>(column.getExpr().getExceptReplaceClause().toString(), replace.getExpr()));
                                                                                                replaceColumnMap.put(replace.getIdentifier().toString(), replace.getIdentifier());
                                                                                        }
                                                                                }
                                                                                
                                                                                TObjectName columnObject = column.getFieldAttr();
                                                                                List<TTable> sourceTables = columnObject.getSourceTableList();
                                                                                if (sourceTables != null && !sourceTables.isEmpty()) {
                                                                                        boolean[] determine = new boolean[sourceTables.size()];
                                                                                        // the one * of the tables whose columns are not known, and those tables
                                                                                        ResultColumn starColumn = null;
                                                                                        List<TTable> unexpanded = new ArrayList<TTable>();
                                                                                        for (int k = 0; k < sourceTables.size(); k++) {
                                                                                                TTable sourceTable = sourceTables.get(k);
                                                                                                Object tableModel = modelManager.getModel(sourceTable);
                                                                                                List<TableColumn> starColumns = tableModel instanceof Table
                                                                                                                ? starExpansionColumns((Table) tableModel) : null;
                                                                                                // a table several SELECT ... INTO statements made, in the query an INSERT reads by
                                                                                                // position: the first one's columns, each read with the columns the others wrote at
                                                                                                // its position (Mantis 4860); a reference by name reads the column of its name
                                                                                                List<List<TableColumn>> alternatives = starColumns == null && isInsertSubquery(stmt)
                                                                                                                && tableModel instanceof Table && sourceTables.size() == 1
                                                                                                                && column.getExceptColumnList() == null && replaceAsIdentifierMap.isEmpty()
                                                                                                                ? starAlternatives((Table) tableModel) : null;
                                                                                                if (alternatives != null) {
                                                                                                        starColumns = alternatives.get(0);
                                                                                                }
                                                                                                if (starColumns != null) {
                                                                                                        for (int j = 0; j < starColumns.size(); j++) {
                                                                                                                TableColumn tableColumn = starColumns.get(j);
                                                                                                                if (column.getExceptColumnList() != null) {
                                                                                                                        boolean except = false;
                                                                                                                        for (TObjectName objectName : column.getExceptColumnList()) {
                                                                                                                                if(DlineageUtil.sameColumnName(objectName.toString(), tableColumn.getName())) {
                                                                                                                                        except = true;
                                                                                                                                        break;
                                                                                                                                }
                                                                                                                        }
                                                                                                                        if (!except && tableColumn.isStruct()) {
                                                                                                                                List<String> names = SQLUtil
                                                                                                                                                .parseNames(tableColumn.getName());
                                                                                                                                for (String name : names) {
                                                                                                                                        for (TObjectName objectName : column
                                                                                                                                                        .getExceptColumnList()) {
                                                                                                                                                if (DlineageUtil.sameColumnName(objectName.toString(), name)) {
                                                                                                                                                        except = true;
                                                                                                                                                        break;
                                                                                                                                                }
                                                                                                                                        }
                                                                                                                                        if (except) {
                                                                                                                                                break;
                                                                                                                                        }
                                                                                                                                }
                                                                                                                        }
                                                                                                                        if(except){
                                                                                                                                continue;
                                                                                                                        }
                                                                                                                }
                                                                                                                
                                                                                                                if (replaceAsIdentifierMap.containsKey(tableColumn.getName())) {
                                                                                                                        Pair<String, TExpression> expr = replaceAsIdentifierMap.get(tableColumn.getName());
                                                                                                                        ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel, replaceColumnMap.get(tableColumn.getName()));
                                                                                                                        Transform transform = new Transform();
                                                                                                                        transform.setType(Transform.EXPRESSION);
                                                                                                                        TObjectName expression = new TObjectName();
                                                                                                                        expression.setString(expr.first);
                                                                                                                transform.setCode(expression);
                                                                                                                        resultColumn.setTransform(transform);
                                                                                                                        analyzeResultColumnExpressionRelation(resultColumn, expr.second);
                                                                                                                }
                                                                                                                else {
                                                                                                                        String columnName = LegacyDlineageWireNamesV1.columnName(tableColumn.getName());
                                                                                                                        Object identity = tableColumn.getIdentifierKey() != null ? tableColumn.getIdentifierKey() : columnName;
                                                                                                                        //bigquery
                                                                                                                        boolean exist = false;
                                                                                                                        boolean collisionRenamed = false;
                                                                                                                        if (!columnName.matches("(?i)f\\d+_")) {
                                                                                                                                List<TTable> publishers = tablesByIdentity.get(identity);
                                                                                                                                if (publishers == null) {
                                                                                                                                        publishers = new ArrayList<TTable>();
                                                                                                                                        tablesByIdentity.put(identity, publishers);
                                                                                                                                }
                                                                                                                                List<TTable> earlierPublishers = new ArrayList<TTable>(publishers);
                                                                                                                                if (!publishers.contains(sourceTable)) {
                                                                                                                                        publishers.add(sourceTable);
                                                                                                                                }
                                                                                                                                if (columnIdentities.add(identity) || !keyMap.containsKey(columnName)) {
                                                                                                                                        keyMap.put(columnName, new AtomicInteger(0));
                                                                                                                                } else {
                                                                                                                                        boolean usingMerged = columnName.indexOf("*") == -1
                                                                                                                                                        && isUsingMerged(stmt, tableColumn, sourceTable, earlierPublishers);
                                                                                                                                        while (columnNames.contains(columnName)) {
                                                                                                                                                if (usingMerged) {
                                                                                                                                                        exist = true;
                                                                                                                                                        break;
                                                                                                                                                } else if (keyMap.containsKey(columnName)) {
                                                                                                                                                        int index = keyMap.get(columnName)
                                                                                                                                                                        .incrementAndGet();
                                                                                                                                                                        columnName = columnName + index;
                                                                                                                                                                        collisionRenamed = true;
                                                                                                                                                }
                                                                                                                                        }
                                                                                                                                }
                                                                                                                                columnNames.add(columnName);
                                                                                                                        }
                                                                                                                        if (exist) {
                                                                                                                                String targetColumn = columnName;
                                                                                                                                DataFlowRelationship relation = modelFactory
                                                                                                                                                .createDataFlowRelation();
                                                                                                                                relation.setEffectType(EffectType.select);
                                                                                                                                relation.setTarget(new ResultColumnRelationshipElement(
                                                                                                                                                resultSetModel.getColumns().stream()
                                                                                                                                                                .filter(t -> SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn,
                                                                                                                                                                                t.getName(), tableColumn.getName()))
                                                                                                                                                                .findFirst().get()));
                                                                                                                                relation.addSource(new TableColumnRelationshipElement(
                                                                                                                                                tableColumn));
                                                                                                                                continue;
                                                                                                                        }
                                                                                                                        // Normal-form bookkeeping over synthetic collision-renamed keys
                                                                                                                        // (columnName may carry an appended index) — NOT identifier
                                                                                                                        // equality; stays on normalized-key compare by design (P0d.3c2),
                                                                                                                        // narrowed only where two names differ just in case (NormalNameCollisions).
                                                                                                                        // A name the collision bookkeeping did not rename is published as its source's own,
                                                                                                                        // unless the rendering is not stable under re-rendering (Oracle """Name"""), where
                                                                                                                        // output version 1 keeps the rendered name.
                                                                                                                        if (!collisionRenamed && DlineageUtil.sameColumnNormalName(columnName,
                                                                                                                                        LegacyDlineageWireNamesV1.columnName(columnName))) {
                                                                                                                                columnName = tableColumn.getName();
                                                                                                                        }
                                                                                                                        ResultColumn resultColumn = modelFactory.createStarResultColumn(resultSetModel, column, columnName);
                                                                                                                        resultColumn.inheritStarColumn(tableColumn);
                                                                                                                        if (!collisionRenamed) resultColumn.inheritIdentifier(tableColumn);
                                                                                                                        resultColumn.setStruct(tableColumn.isStruct());
                                                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                        relation.setEffectType(EffectType.select);
                                                                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                                        Set<TableColumn> read = Collections.newSetFromMap(new IdentityHashMap<TableColumn, Boolean>());
                                                                                                                        read.add(tableColumn);
                                                                                                                        for (int alt = 1; alternatives != null && alt < alternatives.size(); alt++) {
                                                                                                                                if (read.add(alternatives.get(alt).get(j))) {
                                                                                                                                        relation.addSource(new TableColumnRelationshipElement(alternatives.get(alt).get(j)));
                                                                                                                                }
                                                                                                                        }
                                                                                                                }
                                                                                                        }
                                                                                                        determine[k] = true;
                                                                                                        continue;
                                                                                                }
                                                                                                else if (tableModel instanceof ResultSet && ((ResultSet) tableModel).isDetermined()) {
                                                                                                        ResultSet table = (ResultSet) tableModel;
                                                                                                        for (int j = 0; j < table.getColumns().size(); j++) {
                                                                                                                ResultColumn tableColumn = table.getColumns().get(j);
                                                                                                                if (column.getExceptColumnList() != null) {
                                                                                                                        boolean except = false;
                                                                                                                        for (TObjectName objectName : column.getExceptColumnList()) {
                                                                                                                                if(DlineageUtil.sameColumnName(objectName.toString(), tableColumn.getName())) {
                                                                                                                                        except = true;
                                                                                                                                        break;
                                                                                                                                }
                                                                                                                        }
                                                                                                                        if (!except && tableColumn.isStruct()) {
                                                                                                                                List<String> names = SQLUtil
                                                                                                                                                .parseNames(tableColumn.getName());
                                                                                                                                for (String name : names) {
                                                                                                                                        for (TObjectName objectName : column
                                                                                                                                                        .getExceptColumnList()) {
                                                                                                                                                if (DlineageUtil.sameColumnName(objectName.toString(), name)) {
                                                                                                                                                        except = true;
                                                                                                                                                        break;
                                                                                                                                                }
                                                                                                                                        }
                                                                                                                                        if (except) {
                                                                                                                                                break;
                                                                                                                                        }
                                                                                                                                }
                                                                                                                        }
                                                                                                                        if(except){
                                                                                                                                continue;
                                                                                                                        }
                                                                                                                }
                                                                                                                if (replaceAsIdentifierMap.containsKey(tableColumn.getName())) {
                                                                                                                        Pair<String, TExpression> expr = replaceAsIdentifierMap.get(tableColumn.getName());
                                                                                                                        ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel, replaceColumnMap.get(tableColumn.getName()));
                                                                                                                        Transform transform = new Transform();
                                                                                                                        transform.setType(Transform.EXPRESSION);
                                                                                                                        TObjectName expression = new TObjectName();
                                                                                                                        expression.setString(expr.first);
                                                                                                                transform.setCode(expression);
                                                                                                                        resultColumn.setTransform(transform);
                                                                                                                        analyzeResultColumnExpressionRelation(resultColumn, expr.second);
                                                                                                                }
                                                                                                                else if(tableColumn.getRefColumnName()!=null) {
                                                                                                                        ResultColumn resultColumn = modelFactory.createStarResultColumn(resultSetModel, column, tableColumn.getRefColumnName(), tableColumn);
                                                                                                                        if(tableColumn.isStruct()) {
                                                                                                                                resultColumn.setStruct(true);
                                                                                                                        }
                                                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                        relation.setEffectType(EffectType.select);
                                                                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                                                }
                                                                                                                else {
                                                                                                                        String columnName = LegacyDlineageWireNamesV1.columnName(tableColumn.getName());
                                                                                                                        Object identity = tableColumn.getIdentifierKey() != null ? tableColumn.getIdentifierKey() : columnName;
                                                                                                                        //bigquery
                                                                                                                        boolean collisionRenamed = false;
                                                                                                                        if (!columnName.matches("(?i)f\\d+_")) {
                                                                                                                                if (columnIdentities.add(identity) || !keyMap.containsKey(columnName)) {
                                                                                                                                        keyMap.put(columnName, new AtomicInteger(0));
                                                                                                                                } else {
                                                                                                                                        while (columnNames.contains(columnName)) {
                                                                                                                                                int index = keyMap.get(columnName)
                                                                                                                                                                .incrementAndGet();
                                                                                                                                                                columnName = columnName + index;
                                                                                                                                                                collisionRenamed = true;
                                                                                                                                        }
                                                                                                                                }
                                                                                                                                columnNames.add(columnName);
                                                                                                                        }
                                                                                                                        // Normal-form bookkeeping over synthetic collision-renamed keys
                                                                                                                        // (columnName may carry an appended index) — NOT identifier
                                                                                                                        // equality; stays on normalized-key compare by design (P0d.3c2),
                                                                                                                        // narrowed only where two names differ just in case (NormalNameCollisions).
                                                                                                                        // A name the collision bookkeeping did not rename is published as its source's own,
                                                                                                                        // unless the rendering is not stable under re-rendering (Oracle """Name"""), where
                                                                                                                        // output version 1 keeps the rendered name.
                                                                                                                        if (!collisionRenamed && DlineageUtil.sameColumnNormalName(columnName,
                                                                                                                                        LegacyDlineageWireNamesV1.columnName(columnName))) {
                                                                                                                                columnName = tableColumn.getName();
                                                                                                                        }
                                                                                                                        if (modelManager.getModel(column) instanceof ResultColumn) {
                                                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                                relation.setEffectType(EffectType.select);
                                                                                                                                relation.setTarget(new ResultColumnRelationshipElement((ResultColumn)modelManager.getModel(column)));
                                                                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                                                        }
                                                                                                                        else {
                                                                                                                                ResultColumn resultColumn = modelFactory.createStarResultColumn(resultSetModel, column, columnName);
                                                                                                                                resultColumn.inheritStarColumn(tableColumn);
                                                                                                                                if (!collisionRenamed) resultColumn.inheritIdentifier(tableColumn);
                                                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                                relation.setEffectType(EffectType.select);
                                                                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                                                        }
                                                                                                                }
                                                                                                        }
                                                                                                        determine[k] = true;
                                                                                                        continue;
                                                                                                }
                                                                                                else {
                                                                                                        ResultColumn resultColumn = starColumn != null ? starColumn
                                                                                                                        : modelFactory.createResultColumn(resultSetModel, column);
                                                                                                        starColumn = resultColumn;
                                                                                                        unexpanded.add(sourceTable);
                                                                                                        if (tableModel instanceof Function) {
                                                                                                
                                                                                                        } else {
                                                                                                                TObjectName[] columns = modelManager
                                                                                                                                .getTableColumns(sourceTable);
                                                                                                                for (int j = 0; j < columns.length; j++) {
                                                                                                                        TObjectName columnName = columns[j];
                                                                                                                        if (columnName == null
                                                                                                                                        || DlineageUtil.isStarName((columnName))) {
                                                                                                                                continue;
                                                                                                                        }
                                                                                                                        if (isStructColumn(columnName)) {
                                                                                                                                continue;
                                                                                                                        }

                                                                                                                        resultColumn.bindStarLinkColumn(columnName);
                                                                                                                        if (column.getExceptColumnList() != null) {
                                                                                                                                for (TObjectName objectName : column
                                                                                                                                                .getExceptColumnList()) {
                                                                                                                                        resultColumn.unbindStarLinkColumn(objectName);
                                                                                                                                }
                                                                                                                        }
                                                                                                                }
                                                                                                                if (tableModel instanceof ResultSet) {
                                                                                                                        ResultSet queryTable = (ResultSet) tableModel;
                                                                                                                        if (!containStarColumn(queryTable)) {
                                                                                                                                resultColumn.setShowStar(false);
                                                                                                                        }
                                                                                                                }
                                                                                                                if (tableModel instanceof Table) {
                                                                                                                        Table table = (Table) tableModel;
                                                                                                                        if (table.isCreateTable()) {
                                                                                                                                resultColumn.setShowStar(false);
                                                                                                                        }
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                        if(!Arrays.toString(determine).contains("false")) {
                                                                                                continue;
                                                                                        }
                                                                                        if (unexpanded.size() < sourceTables.size()) {
                                                                                                // Mantis 4981: the columns of the other tables are already result
                                                                                                // columns of their own, so the * reads only these tables. Expanding
                                                                                                // a table rebinds the item to its columns: the * must be the item's
                                                                                                // model again, or it is never analyzed and these tables are lost.
                                                                                                modelManager.bindModel(column, starColumn);
                                                                                                isDetermined = false;
                                                                                                analyzeStarOfTables(column, columnObject, unexpanded);
                                                                                                // then the item is bound to all its result columns in FROM order, the
                                                                                                // * among them, as an expanded star is: a view, a CTAS or an INSERT
                                                                                                // writes each of them, the * included
                                                                                                modelManager.bindModel(column, itemColumns(resultSetModel, column, starColumn));
                                                                                                continue;
                                                                                        }
                                                                                } else {
                                                                                        ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel, column);
                                                                                        TTableList tables = stmt.getTables();
                                                                                        for (int k = 0; k < tables.size(); k++) {
                                                                                                TTable table = tables.getTable(k);
                                                                                                TObjectName[] columns = modelManager.getTableColumns(table);
                                                                                                for (int j = 0; j < columns.length; j++) {
                                                                                                        TObjectName columnName = columns[j];
                                                                                                        if (columnName == null) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        if (DlineageUtil.isStarName((columnName))) {
                                                                                                                if (modelManager.getModel(table) instanceof Table) {
                                                                                                                        Table tableModel = (Table) modelManager.getModel(table);
                                                                                                                        if (tableModel != null
                                                                                                                                        && !tableModel.getColumns().isEmpty()) {
                                                                                                                                for (TableColumn item : tableModel.getColumns()) {
                                                                                                                                        resultColumn
                                                                                                                                                        .bindStarLinkColumn(item.getColumnObject());
                                                                                                                                        if (table.getSubquery() == null
                                                                                                                                                        && table.getCTE() == null
                                                                                                                                                        && !tableModel.isCreateTable()) {
                                                                                                                                                resultColumn.setShowStar(true);
                                                                                                                                        }
                                                                                                                                }
                                                                                                                        }
                                                                                                                } else if (modelManager.getModel(table) instanceof QueryTable) {
                                                                                                                        QueryTable tableModel = (QueryTable) modelManager
                                                                                                                                        .getModel(table);
                                                                                                                        if (tableModel != null
                                                                                                                                        && !tableModel.getColumns().isEmpty()) {
                                                                                                                                for (ResultColumn item : tableModel.getColumns()) {
                                                                                                                                        if (item.hasStarLinkColumn()) {
                                                                                                                                                for (TObjectName starLinkColumn : item
                                                                                                                                                                .getStarLinkColumnList()) {
                                                                                                                                                        resultColumn
                                                                                                                                                                        .bindStarLinkColumn(starLinkColumn);
                                                                                                                                                }
                                                                                                                                        } else if (item
                                                                                                                                                        .getColumnObject() instanceof TObjectName) {
                                                                                                                                                resultColumn.bindStarLinkColumn(
                                                                                                                                                                (TObjectName) item.getColumnObject());
                                                                                                                                        } else if (item
                                                                                                                                                        .getColumnObject() instanceof TResultColumn) {
                                                                                                                                                TResultColumn queryTableColumn = (TResultColumn) item
                                                                                                                                                                .getColumnObject();
                                                                                                                                                TObjectName tableColumnObject = queryTableColumn
                                                                                                                                                                .getFieldAttr();
                                                                                                                                                if (tableColumnObject != null) {
                                                                                                                                                        resultColumn.bindStarLinkColumn(
                                                                                                                                                                        tableColumnObject);
                                                                                                                                                } else if (queryTableColumn
                                                                                                                                                                .getAliasClause() != null && !item.isStruct()) {
                                                                                                                                                        resultColumn.bindStarLinkColumn(
                                                                                                                                                                        queryTableColumn.getAliasClause()
                                                                                                                                                                                        .getAliasName());
                                                                                                                                                }
                                                                                                                                        }
                                                                                                                                }
                                                                                                                        }
                                                                                                                }
                                                                                                                continue;
                                                                                                        }
                                                                                                        resultColumn.bindStarLinkColumn(columnName);
                                                                                                }
                                                                                        }
                                                                                }
                                                                                isDetermined = false;
                                                                        }
                                                                        else {
                                                                                if(column.getAliasClause()!=null && column.getAliasClause().getColumns()!=null) {
                                                                                        for(TObjectName aliasColumn: column.getAliasClause().getColumns()) {
                                                                                                modelFactory.createResultColumn(resultSetModel, aliasColumn);
                                                                                        }
                                                                                }
                                                                                else {
                                                                                        modelFactory.createResultColumn(resultSetModel, column);
                                                                                }
                                                                        }
                                                                        analyzeResultColumn(column, EffectType.select);
                                                                        // an unaliased constructor keeps its one column and gains a field node per
                                                                        // field, so a column list pairs its fields (rule R8, Codex review of phase 3)
                                                                        if (column.getExpr() != null
                                                                                        && column.getExpr().getExpressionType() == EExpressionType.function_t) {
                                                                                addStructFieldNodes(resultSetModel, column);
                                                                        }
                                                                }
                                                        }
                                                }
                                                if (isDetermined) {
                                                        resultSetModel.setDetermined(isDetermined);
                                                }
                                        }

                                        TSelectSqlStatement parent = getParentSetSelectStmt(stmt);
                                        if (parent != null && parent.getSetOperatorType() != ESetOperatorType.none) {
                                                ResultSet resultSetModel = modelFactory.createResultSet(stmt, false);
                                                if(queryModel == null) {
                                                        queryModel = resultSetModel;
                                                } 

                                                createPseudoImpactRelation(stmt, resultSetModel, EffectType.select);

                                                boolean isDetermined = true;
                                                for (int i = 0; i < stmt.getResultColumnList().size(); i++) {
                                                        TResultColumn column = stmt.getResultColumnList().getResultColumn(i);
                                                        Boolean structStar = analyzeStructStar(resultSetModel, column);
                                                        if (structStar != null) {
                                                                if (!structStar) {
                                                                        isDetermined = false;
                                                                }
                                                                continue;
                                                        }
                                                        if (isStarItem(column)) {
                                                                
                                                                Map<String, Pair<String, TExpression>> replaceAsIdentifierMap = new HashMap<String, Pair<String, TExpression>>();
                                                                Map<String, TObjectName> replaceColumnMap = new HashMap<String, TObjectName>();
                                                                if(column.getReplaceExprAsIdentifiers()!=null && column.getReplaceExprAsIdentifiers().size()>0) {
                                                                        for(TReplaceExprAsIdentifier replace: column.getReplaceExprAsIdentifiers()) {
                                                                                replaceAsIdentifierMap.put(replace.getIdentifier().toString(), new Pair<String, TExpression>(column.getExpr().getExceptReplaceClause().toString(), replace.getExpr()));
                                                                                replaceColumnMap.put(replace.getIdentifier().toString(), replace.getIdentifier());
                                                                        }
                                                                }
                                                                
                                                                TObjectName columnObject = column.getFieldAttr();
                                                                TTable sourceTable = columnObject.getSourceTable();
                                                                List<TTable> starTables = starReadsSeveralTables(columnObject)
                                                                                ? columnObject.getSourceTableList()
                                                                                : sourceTable == null ? Collections.<TTable>emptyList()
                                                                                                : Collections.singletonList(sourceTable);
                                                                if (!starTables.isEmpty()) {
                                                                        if (expandSetBranchStar(stmt, resultSetModel, queryModel, column, starTables,
                                                                                        replaceAsIdentifierMap, replaceColumnMap)) {
                                                                                continue;
                                                                        }
                                                                        isDetermined = false;
                                                                }

                                                                // Mantis 4975: over a join of tables of known columns and of unknown columns, the known ones
                                                                // are result columns of their own where they stand, and the star reads only the others, as
                                                                // in a plain select list (Mantis 4981): the branches pair the columns by position
                                                                // (not with REPLACE, which moves columns, nor over a USING or NATURAL join: Codex review)
                                                                List<TTable> expandedTables = columnObject.getTableToken() == null
                                                                                && replaceAsIdentifierMap.isEmpty() && !mergesJoinColumns(stmt)
                                                                                ? splitSetBranchStarTables(starTables) : Collections.<TTable>emptyList();
                                                                List<TTable> unexpanded = new ArrayList<TTable>();
                                                                ResultColumn resultColumn = null;
                                                                Set<String> earlierNames = new HashSet<String>();
                                                                Set<String> names = new HashSet<String>();
                                                                List<TTable> earlierTables = new ArrayList<TTable>();
                                                                for (TTable starTable : expandedTables.isEmpty() ? Collections.<TTable>emptyList() : starTables) {
                                                                        if (expandedTables.contains(starTable)) {
                                                                                expandSetBranchStarTable(stmt, resultSetModel, queryModel, column, starTable,
                                                                                                replaceAsIdentifierMap, replaceColumnMap, earlierNames, names, earlierTables);
                                                                        } else {
                                                                                if (resultColumn == null) {
                                                                                        resultColumn = modelFactory.createResultColumn(resultSetModel, column);
                                                                                }
                                                                                unexpanded.add(starTable);
                                                                        }
                                                                }
                                                                if (resultColumn == null) {
                                                                        resultColumn = modelFactory.createResultColumn(resultSetModel, column);
                                                                }
                                                                
                                                                if (columnObject.getTableToken() != null && sourceTable != null) {
                                                                        TObjectName[] columns = modelManager.getTableColumns(sourceTable);
                                                                        for (int j = 0; j < columns.length; j++) {
                                                                                TObjectName columnName = columns[j];
                                                                                if (columnName == null || DlineageUtil.isStarName((columnName))) {
                                                                                        continue;
                                                                                }
                                                                                resultColumn.bindStarLinkColumn(columnName);
                                                                        }

                                                                        if (modelManager.getModel(sourceTable) instanceof Table) {
                                                                                Table tableModel = (Table) modelManager.getModel(sourceTable);
                                                                                if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                        for (TableColumn item : tableModel.getColumns()) {
                                                                                                if (DlineageUtil.isStarName((item.getColumnObject()))) {
                                                                                                        continue;
                                                                                                }
                                                                                                resultColumn.bindStarLinkColumn(item.getColumnObject());
                                                                                        }
                                                                                }
                                                                        } else if (modelManager.getModel(sourceTable) instanceof QueryTable) {
                                                                                QueryTable tableModel = (QueryTable) modelManager.getModel(sourceTable);
                                                                                if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                        for (ResultColumn item : tableModel.getColumns()) {
                                                                                                if (item.hasStarLinkColumn()) {
                                                                                                        for (TObjectName starLinkColumn : item.getStarLinkColumnList()) {
                                                                                                                if (DlineageUtil.isStarName((starLinkColumn))) {
                                                                                                                        continue;
                                                                                                                }
                                                                                                                resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                                        }
                                                                                                } else if (item.getColumnObject() instanceof TObjectName) {
                                                                                                        TObjectName starLinkColumn = (TObjectName) item.getColumnObject();
                                                                                                        if (DlineageUtil.isStarName((starLinkColumn))) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }

                                                                } else {
                                                                        TTableList tables = stmt.getTables();
                                                                        for (int k = 0; k < tables.size(); k++) {
                                                                                TTable table = tables.getTable(k);
                                                                                if (expandedTables.contains(table)) {
                                                                                        continue;
                                                                                }
                                                                                TObjectName[] columns = modelManager.getTableColumns(table);
                                                                                for (int j = 0; j < columns.length; j++) {
                                                                                        TObjectName columnName = columns[j];
                                                                                        if (columnName == null) {
                                                                                                continue;
                                                                                        }
                                                                                        if (DlineageUtil.isStarName((columnName))) {
                                                                                                if (modelManager.getModel(table) instanceof Table) {
                                                                                                        Table tableModel = (Table) modelManager.getModel(table);
                                                                                                        if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                                                for (TableColumn item : tableModel.getColumns()) {
                                                                                                                        resultColumn.bindStarLinkColumn(item.getColumnObject());
                                                                                                                }
                                                                                                        }
                                                                                                } else if (modelManager.getModel(table) instanceof QueryTable) {
                                                                                                        QueryTable tableModel = (QueryTable) modelManager.getModel(table);
                                                                                                        if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                                                for (ResultColumn item : tableModel.getColumns()) {
                                                                                                                        if (item.hasStarLinkColumn()) {
                                                                                                                                for (TObjectName starLinkColumn : item
                                                                                                                                                .getStarLinkColumnList()) {
                                                                                                                                        resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                                                                }
                                                                                                                        } else if (item.getColumnObject() instanceof TObjectName) {
                                                                                                                                resultColumn.bindStarLinkColumn(
                                                                                                                                                (TObjectName) item.getColumnObject());
                                                                                                                        } else if (item
                                                                                                                                        .getColumnObject() instanceof TResultColumn) {
                                                                                                                                TResultColumn queryTableColumn = (TResultColumn) item
                                                                                                                                                .getColumnObject();
                                                                                                                                TObjectName tableColumnObject = queryTableColumn
                                                                                                                                                .getFieldAttr();
                                                                                                                                if (tableColumnObject != null) {
                                                                                                                                        resultColumn.bindStarLinkColumn(tableColumnObject);
                                                                                                                                } else if (queryTableColumn.getAliasClause() != null) {
                                                                                                                                        resultColumn.bindStarLinkColumn(queryTableColumn
                                                                                                                                                        .getAliasClause().getAliasName());
                                                                                                                                }
                                                                                                                        }
                                                                                                                }
                                                                                                        }
                                                                                                }

                                                                                                continue;
                                                                                        }
                                                                                        resultColumn.bindStarLinkColumn(columnName);
                                                                                }
                                                                        }
                                                                }
                                                                if (!expandedTables.isEmpty()) {
                                                                        // the star reads only the other tables, and the item is all its result columns in
                                                                        // FROM order, as in a plain select list (Mantis 4981)
                                                                        modelManager.bindModel(column, resultColumn);
                                                                        analyzeStarOfTables(column, columnObject, unexpanded);
                                                                        modelManager.bindModel(column, itemColumns(resultSetModel, column, resultColumn));
                                                                        continue;
                                                                }
                                                        }
                                                        else {
                                                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel, column);
                                                        }
                                                        analyzeResultColumn(column, EffectType.select);
                                                        if (!isStarItem(column)) {
                                                                // a STRUCT a branch of a set operation builds keeps its fields: field nodes below
                                                                // the item's one column (rule R8, plan acceptance row 26)
                                                                addStructFieldNodes(resultSetModel, column);
                                                        }

                                                }
                                                
                                                resultSetModel.setDetermined(isDetermined);
                                        }
                                } else {
                                        for (int i = 0; i < stmt.getResultColumnList().size(); i++) {
                                                TResultColumn column = stmt.getResultColumnList().getResultColumn(i);

                                                if (!(queryModel instanceof ResultSet)) {
                                                        continue;
                                                }
                                                
                                                ResultSet resultSetModel = (ResultSet)queryModel;
                                                        
                                                if (analyzeStructStar(resultSetModel, column) != null) {
                                                        continue;
                                                }
                                                if (isStarItem(column)) {
                                                        TObjectName columnObject = column.getFieldAttr();
                                                        TTable sourceTable = columnObject.getSourceTable();
                                                        if (column.toString().indexOf(".") == -1 && stmt.getTables().size() > 1) {
                                                                sourceTable = null;
                                                        }
                                                        if (sourceTable != null) {
                                                                {
                                                                        Object tableModel = modelManager.getModel(sourceTable);
                                                                        if (tableModel instanceof Table && ((Table) tableModel).isCreateTable()) {
                                                                                Table table = (Table) tableModel;
                                                                                for (int j = 0; j < table.getColumns().size(); j++) {
                                                                                        TableColumn tableColumn = table.getColumns().get(j);
                                                                                        if (column.getExceptColumnList() != null) {
                                                                                                boolean except = false;
                                                                                                for (TObjectName objectName : column.getExceptColumnList()) {
                                                                                                        if (DlineageUtil.sameColumnName(objectName.toString(), tableColumn.getName())) {
                                                                                                                except = true;
                                                                                                                break;
                                                                                                        }
                                                                                                }
                                                                                                if (!except && tableColumn.isStruct()) {
                                                                                                        List<String> names = SQLUtil
                                                                                                                        .parseNames(tableColumn.getName());
                                                                                                        for (String name : names) {
                                                                                                                for (TObjectName objectName : column
                                                                                                                                .getExceptColumnList()) {
                                                                                                                        if (DlineageUtil.sameColumnName(objectName.toString(), name)) {
                                                                                                                                except = true;
                                                                                                                                break;
                                                                                                                        }
                                                                                                                }
                                                                                                                if (except) {
                                                                                                                        break;
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                                if (except) {
                                                                                                        continue;
                                                                                                }
                                                                                        }
                                                                                        ResultColumn resultColumn = modelFactory.createStarResultColumn(
                                                                                                        resultSetModel, column, tableColumn.getName(), tableColumn);
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.select);
                                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                }
                                                                                if(stmt.getResultColumnList().size() == 1) {
                                                                                        resultSetModel.setDetermined(true);
                                                                                }
                                                                                else {
                                                                                        int starCount = 0;
                                                                                        for (int j = 0; j < stmt.getResultColumnList().size(); j++) {
                                                                                                if (isStarItem(stmt.getResultColumnList().getResultColumn(j))) {
                                                                                                        starCount += 1;
                                                                                                }
                                                                                        }
                                                                                        if (starCount <= 1) {
                                                                                                resultSetModel.setDetermined(true);
                                                                                        }
                                                                                }
                                                                                continue;
                                                                        } else if (tableModel instanceof ResultSet
                                                                                        && ((ResultSet) tableModel).isDetermined()) {
                                                                                ResultSet table = (ResultSet) tableModel;
                                                                                for (int j = 0; j < table.getColumns().size(); j++) {
                                                                                        ResultColumn tableColumn = table.getColumns().get(j);
                                                                                        if (column.getExceptColumnList() != null) {
                                                                                                boolean except = false;
                                                                                                for (TObjectName objectName : column.getExceptColumnList()) {
                                                                                                        if (DlineageUtil.sameColumnName(objectName.toString(), tableColumn.getName())) {
                                                                                                                except = true;
                                                                                                                break;
                                                                                                        }
                                                                                                }
                                                                                                if (!except && tableColumn.isStruct()) {
                                                                                                        List<String> names = SQLUtil
                                                                                                                        .parseNames(tableColumn.getName());
                                                                                                        for (String name : names) {
                                                                                                                for (TObjectName objectName : column
                                                                                                                                .getExceptColumnList()) {
                                                                                                                        if (DlineageUtil.sameColumnName(objectName.toString(), name)) {
                                                                                                                                except = true;
                                                                                                                                break;
                                                                                                                        }
                                                                                                                }
                                                                                                                if (except) {
                                                                                                                        break;
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                                if (except) {
                                                                                                        continue;
                                                                                                }
                                                                                        }
                                                                                        if (tableColumn.getRefColumnName() != null) {
                                                                                                ResultColumn resultColumn = modelFactory.createStarResultColumn(
                                                                                                                (ResultSet)queryModel, column, tableColumn.getRefColumnName(), tableColumn);
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(EffectType.select);
                                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                        } else {
                                                                                                ResultColumn resultColumn = modelFactory.createStarResultColumn(
                                                                                                                resultSetModel, column, tableColumn.getName(), tableColumn);
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(EffectType.select);
                                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                        }
                                                                                }
                                                                                if(stmt.getResultColumnList().size() == 1) {
                                                                                        resultSetModel.setDetermined(true);
                                                                                }
                                                                                else {
                                                                                        int starCount = 0;
                                                                                        for (int j = 0; j < stmt.getResultColumnList().size(); j++) {
                                                                                                if (isStarItem(stmt.getResultColumnList().getResultColumn(j))) {
                                                                                                        starCount += 1;
                                                                                                }
                                                                                        }
                                                                                        if (starCount <= 1) {
                                                                                                resultSetModel.setDetermined(true);
                                                                                        }
                                                                                }
                                                                                continue;
                                                                        }
                                                                }
                                                                
                                                                ResultColumn resultColumn  = modelFactory.createResultColumn(resultSetModel, column);   
                                                                if (modelManager.getModel(sourceTable) instanceof Table) {
                                                                        Table tableModel = (Table) modelManager.getModel(sourceTable);
                                                                        if (tableModel != null) {
                                                                                modelFactory.createTableColumn(tableModel, columnObject, false);
                                                                        }
                                                                        TObjectName[] columns = modelManager.getTableColumns(sourceTable);
                                                                        for (int j = 0; j < columns.length; j++) {
                                                                                TObjectName columnName = columns[j];
                                                                                if (columnName == null || DlineageUtil.isStarName((columnName))) {
                                                                                        continue;
                                                                                }
                                                                                resultColumn.bindStarLinkColumn(columnName);
                                                                        }

                                                                        if (tableModel.getColumns() != null) {
                                                                                for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                                                        TableColumn tableColumn = tableModel.getColumns().get(j);
                                                                                        TObjectName columnName = tableColumn.getColumnObject();
                                                                                        if (columnName == null || DlineageUtil.isStarName((columnName))) {
                                                                                                continue;
                                                                                        }
                                                                                        resultColumn.bindStarLinkColumn(columnName);
                                                                                }
                                                                        }
                                                                } else if (modelManager.getModel(sourceTable) instanceof QueryTable) {
                                                                        QueryTable tableModel = (QueryTable) modelManager.getModel(sourceTable);
                                                                        if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                for (ResultColumn item : tableModel.getColumns()) {
                                                                                        if (item.hasStarLinkColumn()) {
                                                                                                for (TObjectName starLinkColumn : item.getStarLinkColumnList()) {
                                                                                                        resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                                }
                                                                                        } else if (item.getColumnObject() instanceof TObjectName) {
                                                                                                resultColumn.bindStarLinkColumn((TObjectName) item.getColumnObject());
                                                                                        } else if (item.getColumnObject() instanceof TResultColumn) {
                                                                                                TResultColumn queryTableColumn = (TResultColumn) item.getColumnObject();
                                                                                                TObjectName tableColumnObject = queryTableColumn.getFieldAttr();
                                                                                                if (tableColumnObject != null) {
                                                                                                        resultColumn.bindStarLinkColumn(tableColumnObject);
                                                                                                } else if (queryTableColumn.getAliasClause() != null) {
                                                                                                        resultColumn.bindStarLinkColumn(
                                                                                                                        queryTableColumn.getAliasClause().getAliasName());
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        } else {
                                                                ResultColumn resultColumn  = modelFactory.createResultColumn(resultSetModel, column);   
                                                                TTableList tables = stmt.getTables();
                                                                for (int k = 0; k < tables.size(); k++) {
                                                                        TTable table = tables.getTable(k);
                                                                        TObjectName[] columns = modelManager.getTableColumns(table);
                                                                        for (int j = 0; j < columns.length; j++) {
                                                                                TObjectName columnName = columns[j];
                                                                                if (columnName == null) {
                                                                                        continue;
                                                                                }
                                                                                if (DlineageUtil.isStarName((columnName))) {
                                                                                        if (modelManager.getModel(table) instanceof Table) {
                                                                                                Table tableModel = (Table) modelManager.getModel(table);
                                                                                                if (tableModel != null) {
                                                                                                        modelFactory.createTableColumn(tableModel, columnName, false);
                                                                                                }
                                                                                                if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                                        for (int z = 0; z < tableModel.getColumns().size(); z++) {
                                                                                                                resultColumn.bindStarLinkColumn(
                                                                                                                                tableModel.getColumns().get(z).getColumnObject());
                                                                                                        }
                                                                                                }
                                                                                        } else if (modelManager.getModel(table) instanceof QueryTable) {
                                                                                                QueryTable tableModel = (QueryTable) modelManager.getModel(table);
                                                                                                if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                                        for (ResultColumn item : tableModel.getColumns()) {
                                                                                                                if (item.hasStarLinkColumn()) {
                                                                                                                        for (TObjectName starLinkColumn : item
                                                                                                                                        .getStarLinkColumnList()) {
                                                                                                                                resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                                                        }
                                                                                                                } else if (item.getColumnObject() instanceof TObjectName) {
                                                                                                                        resultColumn.bindStarLinkColumn(
                                                                                                                                        (TObjectName) item.getColumnObject());
                                                                                                                } else if (item.getColumnObject() instanceof TResultColumn) {
                                                                                                                        TResultColumn queryTableColumn = (TResultColumn) item
                                                                                                                                        .getColumnObject();
                                                                                                                        TObjectName tableColumnObject = queryTableColumn
                                                                                                                                        .getFieldAttr();
                                                                                                                        if (tableColumnObject != null) {
                                                                                                                                resultColumn.bindStarLinkColumn(tableColumnObject);
                                                                                                                        } else if (queryTableColumn.getAliasClause() != null) {
                                                                                                                                resultColumn.bindStarLinkColumn(queryTableColumn
                                                                                                                                                .getAliasClause().getAliasName());
                                                                                                                        }
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                        continue;
                                                                                }
                                                                                resultColumn.bindStarLinkColumn(columnName);
                                                                        }
                                                                }
                                                        }
                                                }
                                                else {
                                                        ResultColumn resultColumn  = modelFactory.createResultColumn(resultSetModel, column);   
                                                }
                                                
                                                analyzeResultColumn(column, EffectType.select);
                                                if (!isStarItem(column)) {
                                                        // a STRUCT the query of a derived table builds, or passes on, keeps its fields: field
                                                        // nodes below the item's one column (rule R8, Mantis 4893)
                                                        addStructFieldNodes(resultSetModel, column);
                                                }

                                        }
                                        
                                        if (queryModel instanceof ResultSet) {
                                                boolean isDetermined = true;
                                                ResultSet resultSet = (ResultSet) queryModel;
                                                for (ResultColumn column : resultSet.getColumns()) {
                                                        if (column.isStarColumn()) {
                                                                isDetermined = false;
                                                                break;
                                                        }
                                                }
                                                if (isDetermined) {
                                                        resultSet.setDetermined(isDetermined);
                                                }
                                        }
                                }
                        }

                
                        analyzeSelectIntoClause(stmt);
                

                        if (stmt.getJoins() != null && stmt.getJoins().size() > 0) {
                                for (int i = 0; i < stmt.getJoins().size(); i++) {
                                        TJoin join = stmt.getJoins().getJoin(i);
                                        ResultSet topResultSet = (ResultSet) modelManager.getModel(stmt);
                                        if (join.getJoinItems() != null && join.getJoinItems().size() > 0) {
                                                for (int k = 0; k < join.getJoinItems().size(); k++) {
                                                        TTable table = join.getJoinItems().getJoinItem(k).getTable();
                                                        if (table != null && table.getSubquery() != null) {
                                                                
                                                                // A VALUES derived table has no result set of its own (Mantis 4802): its columns
                                                                // live on the query table analyzeValuesDerivedTable filled, already linked to the
                                                                // select list, so there is nothing to match here.
                                                                ResultSet joinResultSet = (ResultSet) modelManager.getModel(table.getSubquery());
                                                                for (int x = 0; joinResultSet != null && x < joinResultSet.getColumns().size(); x++) {
                                                                        ResultColumn sourceColumn = joinResultSet.getColumns().get(x);
                                                                        ResultColumn resultColumn = matchResultColumn(topResultSet.getColumns(),
                                                                                        sourceColumn);
                                                                        if (resultColumn != null
                                                                                        && resultColumn.getColumnObject() instanceof TResultColumn) {
                                                                                TResultColumn column = (TResultColumn) resultColumn.getColumnObject();
                                                                                if (column.getAliasClause() == null && column.getFieldAttr() != null) {
                                                                                        TObjectName resultObject = column.getFieldAttr();
                                                                                        if (resultObject.getSourceTable() == null
                                                                                                        || resultObject.getSourceTable().equals(table)) {
                                                                                                DataFlowRelationship combinedQueryRelation = modelFactory
                                                                                                                .createDataFlowRelation();
                                                                                                combinedQueryRelation.setEffectType(EffectType.select);
                                                                                                combinedQueryRelation
                                                                                                                .setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                combinedQueryRelation
                                                                                                                .addSource(new ResultColumnRelationshipElement(sourceColumn));
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                        
                                                        if(join.getJoinItems().getJoinItem(k).getJoin()!=null) {
                                                                analyzeJoin(join.getJoinItems().getJoinItem(k).getJoin(), EffectType.select);
                                                        }
                                                }
                                        }
                                        analyzeJoin(join, EffectType.select);
                                }
                        }

                        if (stmt.getWhereClause() != null) {
                                TExpression expr = stmt.getWhereClause().getCondition();
                                if (expr != null) {
                                        analyzeFilterCondition(null, expr, null, JoinClauseType.where, EffectType.select);
                                }
                        }

                        // AS OF (SELECT ...) (Oracle, Teradata), AT(TIMESTAMP => (SELECT ...)) (Snowflake): the point in time that a
                        // subquery reads picks the rows read from the table, as a filter does (Mantis 4920)
                        for (int i = 0; i < stmt.tables.size(); i++) {
                                TExpression pointInTime = stmt.tables.getTable(i).getPointInTime();
                                if (pointInTime != null && containsSubquery(pointInTime)) {
                                        analyzeFilterCondition(null, pointInTime, null, JoinClauseType.where, EffectType.select);
                                }
                        }

                        // HAVING filters the groups as WHERE filters the rows: the same fdr on the result's rows
                        if (stmt.getGroupByClause() != null && stmt.getGroupByClause().getHavingClause() != null) {
                                analyzeFilterCondition(null, stmt.getGroupByClause().getHavingClause(), null, JoinClauseType.having,
                                                EffectType.select);
                        }

                        stmtStack.pop();
                }
        }

        /** Whether a subquery, EXISTS included, stands anywhere in {@code expr}, the object of a method call too. */
        private static boolean containsSubquery(TExpression expr) {
                final boolean[] found = { false };
                expr.acceptChildren(new TParseTreeVisitor() {
                        @Override
                        public void preVisit(TExpression node) {
                                if (node.getSubQuery() != null) {
                                        found[0] = true;
                                } else if (node.getExpressionType() == EExpressionType.object_access_t && node.getObjectAccess() != null
                                                && node.getObjectAccess().getObjectExpr() != null) {
                                        // TObjectAccess visits nothing: XMLTYPE((SELECT ...)).getStringVal()
                                        node.getObjectAccess().getObjectExpr().acceptChildren(this);
                                }
                        }
                });
                return found[0];
        }

        protected TObjectNameList getTableLinkedColumns(TTable table) {
                if(structObjectMap.containsKey(table)) {
                        return structObjectMap.get(table);
                }
                return table.getLinkedColumns();
        }

        protected boolean isTopResultSet(TSelectSqlStatement stmt) {
                TCustomSqlStatement parent = stmt.getParentStmt();
                if (parent == null)
                        return true;
                if (parent instanceof TMssqlReturn) {
                        return true;
                }
                if (parent instanceof TReturnStmt) {
                        return true;
                }
                if (parent instanceof TCommonBlock) {
                        TCommonBlock block = (TCommonBlock) parent;
                        if (block.getStatements() != null) {
                                for (int i = 0; i < block.getStatements().size(); i++) {
                                        TCustomSqlStatement child = block.getStatements().get(i);
                                        if(stmt == child) {
                                                return true;
                                        }
                                }
                        }
                }
                if (parent instanceof TMssqlBlock) {
                        TMssqlBlock block = (TMssqlBlock) parent;
                        if (block.getStatements() != null) {
                                for (int i = 0; i < block.getStatements().size(); i++) {
                                        TCustomSqlStatement child = block.getStatements().get(i);
                                        if(stmt == child) {
                                                return true;
                                        }
                                }
                        }
                }
                if (parent instanceof TStoredProcedureSqlStatement) {
                        TStoredProcedureSqlStatement block = (TStoredProcedureSqlStatement) parent;
                        if (block.getStatements() != null) {
                                for (int i = 0; i < block.getStatements().size(); i++) {
                                        TCustomSqlStatement child = block.getStatements().get(i);
                                        if(child == stmt) {
                                                return true;
                                        }
                                        if (child instanceof TReturnStmt) {
                                                TReturnStmt returnStmt = (TReturnStmt) child;
                                                if (returnStmt.getStatements() != null) {
                                                        for (int j = 0; j < returnStmt.getStatements().size(); j++) {
                                                                TCustomSqlStatement child1 = returnStmt.getStatements().get(j);
                                                                if(child1 == stmt) {
                                                                        return true;
                                                                }
                                                        }
                                                }
                                        }
                                        if (child instanceof TMssqlReturn) {
                                                TMssqlReturn returnStmt = (TMssqlReturn) child;
                                                if (returnStmt.getStatements() != null) {
                                                        for (int j = 0; j < returnStmt.getStatements().size(); j++) {
                                                                TCustomSqlStatement child1 = returnStmt.getStatements().get(j);
                                                                if(child1 == stmt) {
                                                                        return true;
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
                return false;
        }

        protected void analyzeTableSubquery(TTable table) {
                if(table.getSubquery()!=null) {
                        QueryTable queryTable = modelFactory.createQueryTable(table);
                        TSelectSqlStatement subquery = table.getSubquery();
                        analyzeSelectStmt(subquery);

                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(subquery);

                        if (resultSetModel != null && resultSetModel != queryTable
                                        && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                impactRelation.setEffectType(EffectType.select);
                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                resultSetModel.getRelationRows()));
                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                queryTable.getRelationRows()));
                        }

                        if (resultSetModel != null && resultSetModel != queryTable
                                        && queryTable.getTableObject().getAliasClause() != null
                                        && queryTable.getTableObject().getAliasClause().getColumns() != null) {
                                for (int j = 0; j < queryTable.getColumns().size()
                                                && j < resultSetModel.getColumns().size(); j++) {
                                        ResultColumn sourceColumn = resultSetModel.getColumns().get(j);
                                        ResultColumn targetColumn = queryTable.getColumns().get(j);

                                        DataFlowRelationship queryRalation = modelFactory.createDataFlowRelation();
                                        queryRalation.setEffectType(EffectType.select);
                                        queryRalation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                        queryRalation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                }
                        } else if (subquery.getSetOperatorType() != ESetOperatorType.none) {
                                SelectSetResultSet selectSetResultSetModel = (SelectSetResultSet) modelManager
                                                .getModel(subquery);
                                for (int j = 0; j < selectSetResultSetModel.getColumns().size(); j++) {
                                        ResultColumn sourceColumn = selectSetResultSetModel.getColumns().get(j);
                                        ResultColumn targetColumn = modelFactory.createSelectSetResultColumn(queryTable,
                                                        sourceColumn);
                                        for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                targetColumn.bindStarLinkColumn(starLinkColumn);
                                        }
                                        DataFlowRelationship selectSetRalation = modelFactory.createDataFlowRelation();
                                        selectSetRalation.setEffectType(EffectType.select);
                                        selectSetRalation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                        selectSetRalation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                }
                        }
                }
        }

        private ResultColumn getPivotedTableColumn(TPivotedTable pivotedTable, TObjectName columnName) {
                List<TPivotClause> pivotClauses = new ArrayList<TPivotClause>();
                if (pivotedTable.getPivotClause() != null) {
                        pivotClauses.add(pivotedTable.getPivotClause());
                }
                if (pivotedTable.getPivotClauseList() != null) {
                        for (int i = 0; i < pivotedTable.getPivotClauseList().size(); i++) {
                                pivotClauses.add(pivotedTable.getPivotClauseList().getElement(i));
                        }
                }
                // identity where the reference and the generated column both carry one ("Store" is not Store in Oracle), else
                // the display comparison this lookup always made: a generated name is display text
                CanonKey referenceKey = DlineageUtil.columnKey(columnName);
                for (TPivotClause clause : pivotClauses) {
                        Object model = modelManager.getModel(clause);
                        if (model instanceof PivotedTable) {
                                PivotedTable pivotedTableModel = (PivotedTable) model;
                                if (pivotedTableModel.getColumns() != null) {
                                        for (ResultColumn column : pivotedTableModel.getColumns()) {
                                                if (referenceKey != null && column.getIdentifierKey() != null
                                                                ? referenceKey.equals(column.getIdentifierKey())
                                                                : DlineageUtil.sameColumnDisplay(SQLUtil.trimColumnStringQuote(column.getName()), columnName)) {
                                                        return column;
                                                }
                                        }
                                }
                        }
                }
                return null;
        }

        private void analyzeHiveTransformClause(TSelectSqlStatement stmt, THiveTransformClause transformClause) {
                Table mapSourceTable = null;
                QueryTable mapQueryTable = null;
                if(stmt.getTables()!=null) {
                        for(int i=0;i<stmt.getTables().size();i++) {
                                TTable table = stmt.getTables().getTable(i);
                                if (table.getSubquery() != null) {
                                        if (transformClause.getTransformType() == ETransformType.ettReduce) {
                                                mapQueryTable = modelFactory.createQueryTable(table);
                                        }
                                        analyzeSelectStmt(table.getSubquery());
                                }
                                else {
                                        mapSourceTable = modelFactory.createTable(table);
                                }
                        }
                }
                
                if (transformClause.getTransformType() == ETransformType.ettReduce) {
                        modelFactory.createResultSet(stmt, false);
                }
                
                List<TableColumn> mapTableColumns = new ArrayList<TableColumn>();
                List<ResultColumn> mapResultSetColumns = new ArrayList<ResultColumn>();
                List<ResultColumn> redueResultSetColumns = new ArrayList<ResultColumn>();
                
                if(transformClause.getExpressionList()!=null) {
                        for(TExpression expression: transformClause.getExpressionList()) {
                                if(expression.getObjectOperand()!=null) {
                                        if (transformClause.getTransformType() == ETransformType.ettMap || transformClause.getTransformType() == ETransformType.ettSelect) {
                                                if (mapSourceTable != null) {
                                                        TableColumn tableColumn = modelFactory.createTableColumn(mapSourceTable,
                                                                        expression.getObjectOperand(), false);
                                                        if (tableColumn != null) {
                                                                mapTableColumns.add(tableColumn);
                                                        }
                                                }
                                        }
                                        else if (transformClause.getTransformType() == ETransformType.ettReduce) {
                                                if (mapQueryTable != null) {
                                                        ResultColumn resultColumn = modelFactory.createResultColumn(mapQueryTable,
                                                                        expression.getObjectOperand(), false);
                                                        if (resultColumn != null) {
                                                                mapResultSetColumns.add(resultColumn);
                                                        }
                                                }
                                        }
                                }
                        }
                }
                
                if (transformClause.getAliasClause() != null) {
                        Object model = modelManager.getModel(stmt);
                        if (model instanceof ResultSet) {
                                ResultSet result = (ResultSet) model;
                                if (result!=null && transformClause.getAliasClause().getColumns() != null) {
                                        for (TObjectName column : transformClause.getAliasClause().getColumns()) {
                                                ResultColumn resultColumn = modelFactory.createResultColumn(result, column);
                                                if (resultColumn != null) {
                                                        if (transformClause.getTransformType() == ETransformType.ettMap 
                                                                        || transformClause.getTransformType() == ETransformType.ettSelect) {
                                                                mapResultSetColumns.add(resultColumn);
                                                        }
                                                        else if (transformClause.getTransformType() == ETransformType.ettReduce) {
                                                                redueResultSetColumns.add(resultColumn);
                                                        }
                                                }
                                        }
                                }
                        }
                }
                
                if (transformClause.getTransformType() == ETransformType.ettMap 
                                || transformClause.getTransformType() == ETransformType.ettSelect) {
                        if (!mapTableColumns.isEmpty() && !mapResultSetColumns.isEmpty()) {
                                for (ResultColumn resultColumn : mapResultSetColumns) {
                                        for (TableColumn tableColumn : mapTableColumns) {
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                relation.setEffectType(EffectType.select);
                                        }
                                }
                        }
                }
                else if (transformClause.getTransformType() == ETransformType.ettReduce) {
                        if (!redueResultSetColumns.isEmpty() && !mapResultSetColumns.isEmpty()) {
                                for (ResultColumn reduceResultColumn : redueResultSetColumns) {
                                        for (ResultColumn mapResultColumn : mapResultSetColumns) {
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setTarget(new ResultColumnRelationshipElement(reduceResultColumn));
                                                relation.addSource(new ResultColumnRelationshipElement(mapResultColumn));
                                                relation.setEffectType(EffectType.select);
                                        }
                                }
                        }
                }
        }

        /**
         * Whether a reference names a column of a table model: by identity where both carry one, else by display, the
         * comparison this check always made (a model column's name is display text).
         */
        private static boolean sameTableColumn(TObjectName reference, TableColumn column) {
                CanonKey referenceKey = DlineageUtil.columnKey(reference);
                return referenceKey != null && column.getIdentifierKey() != null ? referenceKey.equals(column.getIdentifierKey())
                                : DlineageUtil.sameColumnDisplay(column.getName(), reference);
        }

        protected boolean isStructColumn(TObjectName columnName) {
                return columnName.getSourceTable() != null && columnName.getSourceTable().getAliasClause() != null
                                && columnName.getSourceTable().getUnnestClause() != null
                                && DlineageUtil.sameColumnName(columnName, columnName.getSourceTable().getAliasClause().getAliasName());
        }

        private TObjectName getObjectName(ResultColumn column) {
                if (column.getColumnObject() instanceof TResultColumn) {
                        TResultColumn resultColumn = (TResultColumn) column.getColumnObject();
                        if (resultColumn.getAliasClause() != null && resultColumn.getAliasClause().getAliasName() != null) {
                                return resultColumn.getAliasClause().getAliasName();
                        }
                        if (resultColumn.getFieldAttr() != null) {
                                return resultColumn.getFieldAttr();
                        }
                        if (resultColumn.getExpr() != null
                                        && resultColumn.getExpr().getExpressionType() == EExpressionType.simple_object_name_t) {
                                return resultColumn.getExpr().getObjectOperand();
                        }
                } else if (column.getColumnObject() instanceof TObjectName) {
                        return (TObjectName) column.getColumnObject();
                }
                return null;
        }

        private boolean isShowTopSelectResultSet() {
                if (option.isSimpleOutput() && !option.isSimpleShowTopSelectResultSet())
                        return false;
                return true;
        }

        /**
         * The record field the i-th SELECT ... INTO item binds to (#695).
         * SELECT INTO a record is POSITIONAL: item k fills field k. Binding
         * get(0) put every select item on the first field once records expanded
         * to per-field columns — five sources asserted on one field, none on the
         * others. Items beyond the known fields land on the record's star
         * (an unresolved component), never on a wrong field.
         */
        private TableColumn selectIntoRecordColumn(Table tableModel, TableColumn variableColumn, int ordinal) {
                if (variableColumn != null) {
                        return variableColumn;
                }
                List<TableColumn> columns = tableModel.getColumns();
                if (columns == null || columns.isEmpty()) {
                        return null;
                }
                if (columns.size() == 1) {
                        return columns.get(0);
                }
                if (!(tableModel instanceof Variable) || !((Variable) tableModel).isTypeOrderedFields()) {
                        // Fields discovered from consumption carry no positional meaning,
                        // and expanding a star here fans every select item onto every
                        // consumed pseudo-field. Keep the historical whole-record binding.
                        return columns.get(0);
                }
                int k = 0;
                for (TableColumn column : columns) {
                        if (column.isStarColumn()) {
                                continue;
                        }
                        if (k == ordinal) {
                                return column;
                        }
                        k++;
                }
                return tableStarColumn(tableModel);
        }

        private static boolean hasRealTokenPosition(Pair3<Long, Long, String> start) {
                return start != null && start.first != null && start.second != null && start.first > 0
                                && !(start.first == 1L && start.second == 1L);
        }

        /**
         * A SELECT INTO target column minted from a name-only object (star-expanded
         * columns of SELECT * INTO #t, set-operation and expanded-star branches) has
         * no source token, so its position renders as the synthetic
         * "[1,1,0],[1,n,0]" start-of-module coordinate. Give it the producing
         * result column's span instead (for a star column, the '*' token), so
         * definition-site consumers see an honest coordinate.
         */
        private static void fillSyntheticColumnPosition(TableColumn tableColumn, ResultColumn producedBy) {
                if (tableColumn == null || producedBy == null) {
                        return;
                }
                if (hasRealTokenPosition(tableColumn.getStartPosition())) {
                        return;
                }
                if (!hasRealTokenPosition(producedBy.getStartPosition())) {
                        return;
                }
                tableColumn.setStartPosition(producedBy.getStartPosition());
                tableColumn.setEndPosition(producedBy.getEndPosition());
        }

        private void analyzeSelectIntoClause(TSelectSqlStatement stmt) {
                if (stmt.getParentStmt() instanceof TSelectSqlStatement) {
                        return;
                }
                
                // Keep Oracle trigger pseudo-record fields aligned with their INTO
                // expressions. A single shared slot made every source position target the
                // last trigger correlation field in a multi-column list (MantisBT 4707).
                List<TObjectName> oracleIntoColumnNames = new ArrayList<TObjectName>();
                
                TIntoClause intoClause = stmt.getIntoClause();
                
                TSelectSqlStatement leftStmt = DlineageUtil.getLeftStmt(stmt);
                
                if (intoClause == null && leftStmt != null) {
                        intoClause = leftStmt.getIntoClause();
                }
                
                if (intoClause != null) {
                        List<TObjectName> tableNames = new ArrayList<TObjectName>();
                        if (intoClause.getExprList() != null) {
                                for (int j = 0; j < intoClause.getExprList().size(); j++) {
                                        TObjectName tableName = intoClause.getExprList().getExpression(j).getObjectOperand();
                                        if (tableName != null) {
                                                if (tableName.toString().startsWith(":") && option.getVendor() == EDbVendor.dbvoracle
                                                                && tableName.getDbObjectType() == EDbObjectType.column) {
                                                        TObjectName tableAlias = new TObjectName();
                                                        if (!SQLUtil.isEmpty(tableName.getTableString())) {
                                                                tableAlias.setString(tableName.getTableString());
                                                        }
                                                        else {
                                                                tableAlias.setString(tableName.toString());
                                                        }
                                                        tableNames.add(tableAlias);
                                                        TTable sourceTable = tableName.getSourceTable();
                                                        Table boundTable = modelManager.visibleLocal(tableAlias.toString(),
                                                                        LocalSymbolKey.Kind.CORRELATION);
                                                        boolean sourceMatchesBinding = sourceTable != null && boundTable != null
                                                                        && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotTable,
                                                                                        boundTable.getName(), sourceTable.getTableName().toString());
                                                        if (sourceTable != null && (boundTable == null || sourceMatchesBinding)) {
                                                                // Prefer a trigger-correlation binding registered by
                                                                // bindTriggerCorrelationNames(). Resolver fallback can
                                                                // otherwise misclassify a custom REFERENCING alias as the
                                                                // SELECT's only FROM table.
                                                                modelFactory.createTable(sourceTable, tableAlias);
                                                        }
                                                        // A bare host bind such as :first_name is a scalar
                                                        // variable, not a pseudo-record field. Preserve its
                                                        // historical result-column-derived name.
                                                        oracleIntoColumnNames.add(SQLUtil.isEmpty(tableName.getTableString())
                                                                        ? null : tableName);
                                                } else {
                                                        if (tableName != null) {
                                                                tableNames.add(tableName);
                                                                oracleIntoColumnNames.add(null);
                                                        }
                                                }
                                        }
                                        else if(intoClause.getExprList().getExpression(j).getFunctionCall()!=null) {
                                                TObjectName variableName = intoClause.getExprList().getExpression(j).getFunctionCall().getFunctionName();
                                                tableNames.add(variableName);
                                                oracleIntoColumnNames.add(null);
                                                Variable variable = modelFactory.createReferencedVariable(variableName);
                                                variable.setSubType(SubType.record);
                                                TObjectName variableProperties = DlineageUtil.syntheticStarName();
                                                modelFactory.createTableColumn(variable, variableProperties, true);
                                        }
                                }
                        } else if (intoClause.getVariableList() != null) {
                                for (int j = 0; j < intoClause.getVariableList().size(); j++) {
                                        TObjectName tableName = intoClause.getVariableList().getObjectName(j);
                                        if (tableName != null) {
                                                tableNames.add(tableName);
                                                oracleIntoColumnNames.add(null);
                                        }
                                }
                        } else if (intoClause.getIntoName() != null) {
                                tableNames.add(intoClause.getIntoName());
                                oracleIntoColumnNames.add(null);
                        }

                        ResultSet queryModel = (ResultSet) modelManager.getModel(stmt.getResultColumnList());
                        if (stmt.getSetOperatorType() != ESetOperatorType.none) {
                                queryModel = (ResultSet) modelManager.getModel(stmt);
                        }
                        for (int j = 0; j < tableNames.size(); j++) {
                                TObjectName tableName = tableNames.get(j);
                                TObjectName oracleIntoColumnName = oracleIntoColumnNames.get(j);
                                if (tableName.getColumnNameOnly().startsWith("@")
                                                && (option.getVendor() == EDbVendor.dbvmssql || option.getVendor() == EDbVendor.dbvazuresql)) {
                                        continue;
                                }

                                if (tableName.getColumnNameOnly().startsWith(":")
                                                && (option.getVendor() == EDbVendor.dbvhana || option.getVendor() == EDbVendor.dbvteradata)) {
                                        continue;
                                }

                                Table tableModel;
                                TableColumn variableColumn = null;
                                // PL/pgSQL runs no SELECT ... INTO through EXECUTE ("EXECUTE of SELECT ... INTO is not
                                // implemented"), so the INTO name of one in dynamic SQL is no table it creates (Mantis 4857)
                                boolean variableTarget = tableName.getDbObjectType() == EDbObjectType.variable
                                                || (dynamicFoldDepth > 0 && intoClause.getVariableList() != null);

                                if (variableTarget) {
                                        if (tableName.toString().indexOf(".") != -1) {
                                                List<String> splits = SQLUtil.parseNames(tableName.toString());
                                                tableModel = modelFactory.createReferencedVariable(splits.get(splits.size() - 2), true);
                                                // INTO rec.field names its target field explicitly (#695);
                                                // bind that field, never an ordinal of the record.
                                                variableColumn = modelFactory.createTableColumn(tableModel, tableName, true);
                                        } else {
                                                tableModel = modelFactory.createReferencedVariable(tableName);
                                        }
                                        if (tableModel.getSubType() == null) {
                                                tableModel.setSubType(SubType.record);
                                        }
                                        if(variableColumn == null
                                                        && (tableModel.getColumns() == null || tableModel.getColumns().isEmpty())) {
                                                TObjectName variableProperties = DlineageUtil.syntheticStarName();
                                                variableColumn = modelFactory.createTableColumn(tableModel, variableProperties, true);
                                        }
                                } else {
                                        tableModel = modelFactory.createTableByName(tableName);
                                        // SELECT ... INTO <table> creates the target. Parse fact, set
                                        // regardless of isDetermined() (unlike the gated setCreateTable
                                        // below). See dlineage-authoritative-endpoint-classification.md.
                                        tableModel.setCreatedInSql(true);
                                        tableModel.setEndpointIntroduction(EndpointIntroduction.SELECT_INTO);
                                }
                                TableColumn oracleIntoTableColumn = oracleIntoColumnName == null ? null
                                                : modelFactory.createTableColumn(tableModel, oracleIntoColumnName, true);

                                if (queryModel instanceof ResultSet && (stmt.getWhereClause() != null || hasJoin(stmt))) {
                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.setEffectType(EffectType.insert);
                                        impactRelation.addSource(
                                                        new RelationRowsRelationshipElement<ResultSetRelationRows>(((ResultSet)queryModel).getRelationRows()));
                                        impactRelation.setTarget(
                                                        new RelationRowsRelationshipElement<TableRelationRows>(tableModel.getRelationRows()));
                                }
                                
                                Process process = modelFactory.createProcess(stmt);
                                tableModel.addProcess(process);
                                
                                if (stmt.getSetOperatorType() != ESetOperatorType.none) {
                                        for (int setopOrdinal = 0; setopOrdinal < queryModel.getColumns().size(); setopOrdinal++) {
                                                ResultColumn resultColumn = queryModel.getColumns().get(setopOrdinal);
                                                if (tableNames.size() > 1
                                                                && (variableTarget
                                                                                || oracleIntoTableColumn != null)
                                                                && setopOrdinal != j) {
                                                        continue;
                                                }
                                                TableColumn tableColumn;
                                                if (oracleIntoTableColumn != null) {
                                                        tableColumn = oracleIntoTableColumn;
                                                } else if (tableModel.isVariable()) {
                                                        // SELECT ... INTO variables and typed records binds
                                                        // positionally even through a set operation (codex-696 F4).
                                                        tableColumn = selectIntoRecordColumn(tableModel, variableColumn, setopOrdinal);
                                                } else {
                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                        resultColumn);
                                                        fillSyntheticColumnPosition(tableColumn, resultColumn);
                                                }

                                                if (DlineageUtil.isTempTable(tableModel, option.getVendor()) && sqlenv != null
                                                                && tableModel.getDatabase() != null && tableModel.getSchema() != null) {
                                                        TSQLSchema schema = sqlenv
                                                                        .getSQLSchema(tableModel.getDatabase() + "." + tableModel.getSchema(), true);
                                                        if (schema != null) {
                                                                TSQLTable tempTable = schema
                                                                                .createTable(DlineageUtil.getSimpleTableName(tableModel.getName()));
                                                                if (tableColumn.isStarColumn()) {
                                                                        addUnresolvedStar(tempTable);
                                                                } else {
                                                                        tempTable.addColumn(tableColumn.getName());
                                                                }
                                                        }
                                                }

                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.insert);
                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                relation.setProcess(process);
                                        }
                                        
                                        tableModel.setDetermined(queryModel.isDetermined());
                                        recordSelectIntoTarget(stmt, tableModel, tableName, queryModel.isDetermined(), null);
                                        if (j + 1 == tableNames.size()) {
                                                return;
                                        }
                                        continue;
                                }

                                boolean isDetermined = true;
                                // the column each select item writes, in order, while every item writes one known column
                                List<TableColumn> written = new ArrayList<TableColumn>();
                                for (int i = 0; i < stmt.getResultColumnList().size(); i++) {
                                        if (tableNames.size() > 1
                                                        && (variableTarget
                                                                        || oracleIntoTableColumn != null)) {
                                                if (i != j) {
                                                        continue;
                                                }
                                        }
                                        TResultColumn column = stmt.getResultColumnList().getResultColumn(i);
                                        // a star the analysis expanded writes its columns in order (Mantis 4876); one whose columns are not
                                        // known leaves the order of the table's columns unknown, and so does a USING or NATURAL join, whose
                                        // merged columns stand first (Codex review)
                                        boolean expandedStar = isStarItem(column) && column.getFieldAttr() != null
                                                        && column.getFieldAttr().getSourceTable() != null
                                                        && modelManager.getModel(column) instanceof LinkedHashMap && !mergesJoinColumns(stmt);
                                        if (isStarItem(column) && !expandedStar) {
                                                written = null;
                                        }

                                        if (isStarItem(column) && column.getFieldAttr() != null
                                                        && column.getFieldAttr().getSourceTable() != null) {
                                                Object model = modelManager.getModel(column);
                                                if(model instanceof LinkedHashMap) {
                                                        LinkedHashMap<String, ResultColumn> columns = (LinkedHashMap<String, ResultColumn>)model;
                                                        int mapOrdinal = 0;
                                                        for(String key: columns.keySet()) {
                                                                ResultColumn sourceColumn = columns.get(key);
                                                                TableColumn tableColumn;
                                                                if (tableModel instanceof Variable
                                                                                && ((Variable) tableModel).isTypeOrderedFields()) {
                                                                        tableColumn = selectIntoRecordColumn(tableModel, null, mapOrdinal);
                                                                } else {
                                                                        tableColumn = itemColumnTarget(tableModel, sourceColumn);
                                                                        fillSyntheticColumnPosition(tableColumn, sourceColumn);
                                                                }
                                                                if (tableColumn != null && tableColumn.isStarColumn()) {
                                                                        // the * of a star over a join that expanded its other tables (Mantis 4981)
                                                                        isDetermined = false;
                                                                }
                                                                if (written != null) {
                                                                        if (tableColumn != null && !tableColumn.isStarColumn()) {
                                                                                written.add(tableColumn);
                                                                        } else {
                                                                                written = null;
                                                                        }
                                                                }
                                                                mapOrdinal++;
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.insert);
                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                                                relation.setProcess(process);
                                                        }
                                                }
                                                else if(model instanceof ResultColumn) {
                                                        isDetermined = false;
                                                        ResultColumn resultColumn = (ResultColumn) model;
                                                        List<TObjectName> columns = resultColumn.getStarLinkColumnList();
                                                        if (columns.size() > 0) {
                                                                for (int k = 0; k < columns.size(); k++) {
        
                                                                        TableColumn tableColumn;
                                                                        if (tableModel instanceof Variable
                                                                                        && ((Variable) tableModel).isTypeOrderedFields()) {
                                                                                // SELECT * INTO a typed record fills its
                                                                                // DECLARED fields by position — creating
                                                                                // fields from source names left the real
                                                                                // fields with no upstream (codex-696 F4).
                                                                                tableColumn = selectIntoRecordColumn(tableModel, null, k);
                                                                        } else {
                                                                                tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                                columns.get(k));
                                                                                // Star-link names are synthesized without
                                                                                // tokens; the '*' span is the honest
                                                                                // definition site for the expanded column.
                                                                                fillSyntheticColumnPosition(tableColumn, resultColumn);
                                                                        }

                                                                        if (DlineageUtil.isTempTable(tableModel, option.getVendor()) && sqlenv != null
                                                                                        && tableModel.getDatabase() != null && tableModel.getSchema() != null) {
                                                                                TSQLSchema schema = tableMetadataEnvironment(tableModel).getSQLSchema(
                                                                                                tableModel.getDatabase() + "." + tableModel.getSchema(), true);
                                                                                if (schema != null) {
                                                                                        TSQLTable tempTable = schema.createTable(DlineageUtil.getSimpleTableName(tableModel.getName()));
                                                                                        if (tableColumn.isStarColumn()) {
                                                                                                addUnresolvedStar(tempTable);
                                                                                        } else {
                                                                                                tempTable.addColumn(tableColumn.getName());
                                                                                        }
                                                                                }
                                                                        }
        
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.insert);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.setProcess(process);
                                                                }
                                                                if (resultColumn.isShowStar()) {
                                                                        TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                        column.getFieldAttr());
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.insert);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.setProcess(process);
                                                                }
                                                        } else {
                                                                TObjectName columnObject = column.getFieldAttr();
                                                                if (column.getAliasClause() != null) {
                                                                        columnObject = column.getAliasClause().getAliasName();
                                                                }
                                                                if (columnObject != null) {
                                                                        TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                        columnObject);
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.insert);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.setProcess(process);
                                                                } else if (!SQLUtil.isEmpty(column.getColumnAlias())) {
                                                                        TableColumn tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                        column.getAliasClause().getAliasName());
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.insert);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.setProcess(process);
                                                                }
                                                        }
                                                }
                                        } else {
                                                ResultColumn resultColumn = null;

                                                if (queryModel instanceof QueryTable) {
                                                        resultColumn = (ResultColumn) modelManager.getModel(column);
                                                } else if (queryModel instanceof ResultSet) {
                                                        resultColumn = (ResultColumn) modelManager.getModel(column);
                                                } else {
                                                        continue;
                                                }

                                                if (resultColumn == null && column.getAliasClause() != null) {
                                                        resultColumn = (ResultColumn) modelManager.getModel(column.getAliasClause().getAliasName());
                                                }

                                                if (resultColumn != null) {
                                                        TObjectName columnObject = column.getFieldAttr();
                                                        if (column.getAliasClause() != null) {
                                                                columnObject = column.getAliasClause().getAliasName();
                                                        }
                                                        TableColumn tableColumn = null;
                                                        if (columnObject != null) {
                                                                if (tableModel.isVariable()) {
                                                                        tableColumn = selectIntoRecordColumn(tableModel, variableColumn, i);
                                                                } 
                                                                else if (oracleIntoTableColumn != null) {
                                                                        tableColumn = oracleIntoTableColumn;
                                                                }
                                                                else {
                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel, columnObject);
                                                                        if (containStarColumn(queryModel)) {
                                                                                tableColumn.notBindStarLinkColumn(true);
                                                                        }
                                                                }
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.insert);
                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.setProcess(process);
                                                        } else if (!SQLUtil.isEmpty(column.getColumnAlias())) {
                                                                if (tableModel.isVariable()) {
                                                                        tableColumn = selectIntoRecordColumn(tableModel, variableColumn, i);
                                                                } else {
                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel,
                                                                                        column.getAliasClause().getAliasName());
                                                                }
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.insert);
                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.setProcess(process);
                                                        } else {
                                                                if (tableModel.isVariable()) {
                                                                        tableColumn = selectIntoRecordColumn(tableModel, variableColumn, i);
                                                                }
                                                                if (tableColumn != null) {
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.insert);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.setProcess(process);
                                                                }
                                                        }
                                                        if (written != null) {
                                                                if (tableColumn != null) {
                                                                        written.add(tableColumn);
                                                                } else {
                                                                        written = null;
                                                                }
                                                        }
                                                } else {
                                                        written = null;
                                                }
                                        }
                                }
                                tableModel.setDetermined(isDetermined);
                                recordSelectIntoTarget(stmt, tableModel, tableName, isDetermined, written);
                        }
                }
        }

        private boolean isUnPivotedTable(TPivotedTable pivotedTable) {
                if (pivotedTable.getPivotClauseList() != null && pivotedTable.getPivotClauseList().size() > 0) {
                        return pivotedTable.getPivotClauseList().getElement(0).getType() == TPivotClause.unpivot;
                } else {
                        TPivotClause pivotClause = pivotedTable.getPivotClause();
                        return pivotClause.getType() == TPivotClause.unpivot;
                }
        }

        private void analyzeUnPivotedTable(TSelectSqlStatement stmt, TPivotedTable pivotedTable) {
                List<Object> tables = new ArrayList<Object>();
                Set<Object> pivotedColumns = new HashSet<Object>();
                TTable fromTable = pivotedTable.getTableSource();
                Object table = modelManager.getModel(fromTable);
                List<TPivotClause> pivotClauses = new ArrayList<TPivotClause>();
                if (pivotedTable.getPivotClauseList() != null && pivotedTable.getPivotClauseList().size() > 0) {
                        for (int i = 0; i < pivotedTable.getPivotClauseList().size(); i++) {
                                pivotClauses.add(pivotedTable.getPivotClauseList().getElement(i));
                        }
                } else {
                        TPivotClause pivotClause = pivotedTable.getPivotClause();
                        pivotClauses.add(pivotClause);
                }

                for (int y = 0; y < pivotClauses.size(); y++) {
                        TPivotClause pivotClause = pivotClauses.get(y);
                        PivotedTable pivotTable = modelFactory.createPivotdTable(pivotClause);
                        pivotTable.setUnpivoted(true);

                        if (pivotClause.getValueColumnList() != null) {
                                for (int j = 0; j < pivotClause.getValueColumnList().size(); j++) {
                                        modelFactory.createResultColumn(pivotTable, pivotClause.getValueColumnList().getObjectName(j));
                                }
                        }
                        if (pivotClause.getPivotColumnList() != null) {
                                for (int j = 0; j < pivotClause.getPivotColumnList().size(); j++) {
                                        modelFactory.createResultColumn(pivotTable, pivotClause.getPivotColumnList().getObjectName(j));
                                }
                        }
                        if (pivotClause.getUnpivotInClause()!=null && pivotClause.getUnpivotInClause().getItems() != null) {
                                for (int j = 0; j < pivotClause.getUnpivotInClause().getItems().size(); j++) {
                                        TObjectName columnName = pivotClause.getUnpivotInClause().getItems().getElement(j).getColumn();
                                        if (columnName != null) {
                                                if (table instanceof QueryTable) {
                                                        for (ResultColumn tableColumn : ((QueryTable) table).getColumns()) {
                                                                if (DlineageUtil.columnMatches(tableColumn, columnName)) {
                                                                        for (ResultColumn resultColumn : pivotTable.getColumns()) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                pivotedColumns.add(tableColumn);
                                                                        }
                                                                        break;
                                                                }
                                                        }
                                                } else if (table instanceof Table) {
                                                        for (TableColumn tableColumn : ((Table) table).getColumns()) {
                                                                if (DlineageUtil.columnMatches(tableColumn, columnName)) {
                                                                        for (ResultColumn resultColumn : pivotTable.getColumns()) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                pivotedColumns.add(tableColumn);
                                                                        }
                                                                        break;
                                                                }
                                                        }
                                                }
                                        } else {
                                                TObjectNameList columnNames = pivotClause.getUnpivotInClause().getItems().getElement(j)
                                                                .getColumnList();
                                                for (TObjectName columnName1 : columnNames) {
                                                        if (table instanceof QueryTable) {
                                                                for (ResultColumn tableColumn : ((QueryTable) table).getColumns()) {
                                                                        if (DlineageUtil.columnMatches(tableColumn, columnName1)) {
                                                                                for (ResultColumn resultColumn : pivotTable.getColumns()) {
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.select);
                                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                        pivotedColumns.add(tableColumn);
                                                                                }
                                                                                break;
                                                                        }
                                                                }
                                                        } else if (table instanceof Table) {
                                                                for (TableColumn tableColumn : ((Table) table).getColumns()) {
                                                                        if (DlineageUtil.columnMatches(tableColumn, columnName1)) {
                                                                                for (ResultColumn resultColumn : pivotTable.getColumns()) {
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.select);
                                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                        pivotedColumns.add(tableColumn);
                                                                                }
                                                                                break;
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                        tables.add(pivotTable);
                        tables.add(table);
                }

                ResultSet resultSet = modelFactory.createResultSet(stmt,
                                isTopResultSet(stmt) && isShowTopSelectResultSet());
                TResultColumnList columnList = stmt.getResultColumnList();
                for (int i = 0; i < columnList.size(); i++) {
                        TResultColumn column = columnList.getResultColumn(i);
                        ResultColumn resultColumn = modelFactory.createAndBindingSelectSetResultColumn(resultSet, column, i);
                        if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                TResultColumn columnObject = (TResultColumn) resultColumn.getColumnObject();
                                if (columnObject.getFieldAttr() != null) {
                                        if (DlineageUtil.isStarName((columnObject.getFieldAttr()))) {
                                                resultColumn.setShowStar(false);
                                                int index = 0;
                                                for (int k = 0; k < tables.size(); k++) {
                                                        Object tableItem = tables.get(k);
                                                        if (tableItem instanceof ResultSet) {
                                                                for (int x = 0; x < ((ResultSet) tableItem).getColumns().size(); x++) {
                                                                        ResultColumn tableColumn = ((ResultSet) tableItem).getColumns().get(x);
                                                                        if (pivotedColumns.contains(tableColumn)) {
                                                                                continue;
                                                                        }
                                                                        if (tableColumn.getColumnObject() instanceof TObjectName) {
                                                                                resultColumn.bindStarLinkColumn((TObjectName) tableColumn.getColumnObject());
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn, (TObjectName) tableColumn.getColumnObject()));
                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                        } else if (tableColumn.getColumnObject() instanceof TResultColumn) {
                                                                                if (((TResultColumn) tableColumn.getColumnObject()).getFieldAttr() != null) {
                                                                                        if (tableColumn.hasStarLinkColumn()) {
                                                                                                for (int z = 0; z < tableColumn.getStarLinkColumnList().size(); z++) {
                                                                                                        ResultColumn resultColumn1 = modelFactory.createResultColumn(
                                                                                                                        (ResultSet) tableItem,
                                                                                                                        tableColumn.getStarLinkColumnList().get(z));
                                                                                                        DataFlowRelationship relation = modelFactory
                                                                                                                        .createDataFlowRelation();
                                                                                                        relation.setEffectType(EffectType.select);
                                                                                                        relation.setTarget(
                                                                                                                        new ResultColumnRelationshipElement(resultColumn));
                                                                                                        relation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(resultColumn1));
                                                                                                        tableColumn.removeStarLinkOf(tableColumn.getStarLinkColumnList().get(z));
                                                                                                        z--;
                                                                                                }
                                                                                        } else {
                                                                                                resultColumn.bindStarLinkColumn(
                                                                                                                ((TResultColumn) tableColumn.getColumnObject()).getFieldAttr());
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(EffectType.select);
                                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn, ((TResultColumn) tableColumn.getColumnObject()).getFieldAttr()));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                        }
                                                                                } else if (((TResultColumn) tableColumn.getColumnObject()).getExpr() != null) {
                                                                                        TExpression expr = ((TResultColumn) tableColumn.getColumnObject())
                                                                                                        .getExpr();
                                                                                        if (expr.getExpressionType() == EExpressionType.simple_constant_t) {
                                                                                                TObjectName columnName = Column.nameOfText(expr.toString());
                                                                                                resultColumn.bindStarLinkColumn(columnName);
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(EffectType.select);
                                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn, columnName));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        } else if (tableItem instanceof Table) {
                                                                for (TableColumn tableColumn : ((Table) tableItem).getColumns()) {
                                                                        if (pivotedColumns.contains(tableColumn)) {
                                                                                continue;
                                                                        }
                                                                        resultColumn.bindStarLinkColumn((TObjectName) tableColumn.getColumnObject(), index);
                                                                        index++;
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn, (TObjectName) tableColumn.getColumnObject()));
                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                }
                                                        }
                                                }
                                        } else {
                                                for (int k = 0; k < tables.size(); k++) {
                                                        Object tableItem = tables.get(k);
                                                        if (tableItem instanceof ResultSet) {
                                                                for (ResultColumn tableColumn : ((ResultSet) tableItem).getColumns()) {
                                                                        if (DlineageUtil.columnMatches(tableColumn, columnObject.getFieldAttr())) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                break;
                                                                        }
                                                                }
                                                        } else if (tableItem instanceof Table) {
                                                                for (TableColumn tableColumn : ((Table) tableItem).getColumns()) {
                                                                        if (DlineageUtil.columnMatches(tableColumn, columnObject.getFieldAttr())) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                break;
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                } else if (columnObject.getExpr() != null) {
                                        analyzeResultColumn(column, EffectType.select);
                                }
                        }
                }
        }

        private void analyzePivotedTable(TSelectSqlStatement stmt, TPivotedTable pivotedTable) {
                List<Object> tables = new ArrayList<Object>();
                Set<Object> pivotedColumns = new HashSet<Object>();
                TTable fromTable = pivotedTable.getTableSource();
                Object table = modelManager.getModel(fromTable);
                if(table == null && fromTable.getSubquery()!=null) {
                        table = modelFactory.createQueryTable(fromTable);
                        TSelectSqlStatement subquery = fromTable.getSubquery();
                        analyzeSelectStmt(subquery);
                }
                List<TPivotClause> pivotClauses = new ArrayList<TPivotClause>();
                if (pivotedTable.getPivotClauseList() != null && pivotedTable.getPivotClauseList().size() > 0) {
                        for (int i = 0; i < pivotedTable.getPivotClauseList().size(); i++) {
                                pivotClauses.add(pivotedTable.getPivotClauseList().getElement(i));
                        }
                } else {
                        TPivotClause pivotClause = pivotedTable.getPivotClause();
                        pivotClauses.add(pivotClause);
                }

                for (int y = 0; y < pivotClauses.size(); y++) {
                        TPivotClause pivotClause = pivotClauses.get(y);
                        List<TFunctionCall> functionCalls = new ArrayList<TFunctionCall>();
                        if (pivotClause.getAggregation_function() != null || pivotClause.getAggregation_function_list() != null) {
                                if (pivotClause.getAggregation_function() != null) {
                                        functionCalls.add((TFunctionCall) pivotClause.getAggregation_function());
                                } else if (pivotClause.getAggregation_function_list() != null) {
                                        for (int i = 0; i < pivotClause.getAggregation_function_list().size(); i++) {
                                                functionCalls.add((TFunctionCall) pivotClause.getAggregation_function_list().getResultColumn(i)
                                                                .getExpr().getFunctionCall());
                                        }
                                }

                                if (functionCalls.isEmpty()) {
                                        return;
                                }

                                if (pivotClause.getPivotColumnList() == null) {
                                        return;
                                }

                                if (pivotClause.getPivotInClause() == null) {
                                        return;
                                }

                                for (int x = 0; x < functionCalls.size(); x++) {
                                        TFunctionCall functionCall = functionCalls.get(x);
                                        Function function = modelFactory.createFunction(functionCall);
                                        ResultColumn column = modelFactory.createFunctionResultColumn(function,
                                                        ((TFunctionCall) functionCall).getFunctionName());

                                        List<TExpression> expressions = new ArrayList<TExpression>();
                                        getFunctionExpressions(expressions, new ArrayList<TExpression>(), functionCall);

                                        for (int j = 0; j < expressions.size(); j++) {
                                                columnsInExpr visitor = new columnsInExpr();
                                                expressions.get(j).inOrderTraverse(visitor);
                                                List<TObjectName> objectNames = visitor.getObjectNames();
                                                if (objectNames == null) {
                                                        continue;
                                                }
                                                for (TObjectName columnName : objectNames) {
                                                        // STRUCT tree: COUNT(customer.name) reads the field node customer.name, and the column
                                                        // customer is consumed by the aggregate, so it is no grouping column (Mantis 4829)
                                                        String fieldBase = nestedProfile().buildsDeclaredTree()
                                                                        && columnName.getFieldPathRead() != null && columnName.getFieldPathBaseToken() != null
                                                                        ? columnName.getFieldPathBaseToken().toString() : null;
                                                        if (fieldBase != null && table instanceof Table) {
                                                                TableColumn node = modelFactory.createTableColumn((Table) table, columnName, false);
                                                                if (node != null) {
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(column));
                                                                        relation.addSource(new TableColumnRelationshipElement(node));
                                                                        pivotedColumns.add(node);
                                                                        if (node.getDeclaredColumn() != null) {
                                                                                pivotedColumns.add(node.getDeclaredColumn());
                                                                        }
                                                                        for (TableColumn tableColumn : ((Table) table).getColumns()) {
                                                                                if (DlineageUtil.columnMatches(tableColumn, fieldBase)) {
                                                                                        pivotedColumns.add(tableColumn);
                                                                                }
                                                                        }
                                                                        continue;
                                                                }
                                                        }
                                                        if (table instanceof QueryTable) {
                                                                for (int i = 0; i < ((QueryTable) table).getColumns().size(); i++) {
                                                                        boolean find = false;
                                                                        ResultColumn tableColumn = ((QueryTable) table).getColumns().get(i);
                                                                        if (fieldBase != null && !tableColumn.hasStarLinkColumn()
                                                                                        && DlineageUtil.columnMatches(tableColumn, fieldBase)) {
                                                                                // a field read of a CTE or derived column reads that column (Mantis 4829)
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(column));
                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                pivotedColumns.add(tableColumn);
                                                                                break;
                                                                        }
                                                                        if (tableColumn.hasStarLinkColumn()) {
                                                                                for (int k = 0; k < tableColumn.getStarLinkColumnList().size(); k++) {
                                                                                        TObjectName objectName = tableColumn.getStarLinkColumnList().get(k);
                                                                                        if (DlineageUtil.sameColumnName(columnName, objectName)) {
                                                                                                ResultColumn resultColumn = modelFactory
                                                                                                                .createResultColumn((QueryTable) table, objectName);
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(EffectType.select);
                                                                                                relation.setTarget(new ResultColumnRelationshipElement(column));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                                pivotedColumns.add(resultColumn);
                                                                                                tableColumn.removeStarLinkOf(objectName);
                                                                                                find = true;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        } else if (DlineageUtil.columnMatches(tableColumn, columnName)) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(column));
                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                pivotedColumns.add(tableColumn);
                                                                                find = true;
                                                                                break;
                                                                        } 
                                                                        
                                                                        if (!find && tableColumn.isStarColumn()) {
                                                                                QueryTable queryTable = (QueryTable)table;
                                                                                ResultColumn resultColumn = modelFactory.createResultColumn(queryTable, columnName);
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(column));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                tableColumn.bindStarLinkColumn(columnName);
                                                                        }
                                                                }
                                                        } else if (table instanceof Table) {
                                                                for (TableColumn tableColumn : ((Table) table).getColumns()) {
                                                                        if (DlineageUtil.columnMatches(tableColumn, columnName)) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(column));
                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                pivotedColumns.add(tableColumn);
                                                                                break;
                                                                        }
                                                                }
                                                        }
                                                }
                                        }

                                        PivotedTable pivotTable = modelFactory.createPivotdTable(pivotClause);
                                        pivotTable.setUnpivoted(false);

                                        if (pivotClause.getPivotInClause().getItems() != null) {
                                                for (int j = 0; j < pivotClause.getPivotInClause().getItems().size(); j++) {
                                                        ResultColumn resultColumn = null;
                                                        if (pivotClause.getAggregation_function_list() != null
                                                                        && pivotClause.getAggregation_function_list().size() > 1) {
                                                                TResultColumn functionColumn = pivotClause.getAggregation_function_list()
                                                                                .getResultColumn(x);
                                                                TObjectName tableColumn = new TObjectName();
                                                                if (option.getVendor() == EDbVendor.dbvbigquery) {
                                                                        tableColumn.setString(getResultColumnString(functionColumn) + "_"
                                                                                        + SQLUtil.trimColumnStringQuote(getResultColumnString(
                                                                                                        pivotClause.getPivotInClause().getItems().getResultColumn(j))));
                                                                }
                                                                else {
                                                                        tableColumn.setString(SQLUtil
                                                                                        .trimColumnStringQuote(getResultColumnString(
                                                                                                        pivotClause.getPivotInClause().getItems().getResultColumn(j)))
                                                                                        + "_" + getResultColumnString(functionColumn));
                                                                }
                                                                resultColumn = modelFactory.createResultColumn(pivotTable, tableColumn);
                                                        } else {
                                                                resultColumn = modelFactory.createSelectSetResultColumn(pivotTable,
                                                                                pivotClause.getPivotInClause().getItems().getResultColumn(j), j);
                                                        }
                                                        {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(column));
                                                        }
                                                        {
                                                                for (TObjectName columnName : pivotClause.getPivotColumnList()) {
                                                                        if (table instanceof QueryTable) {
                                                                                for (int i = 0; i < ((QueryTable) table).getColumns().size(); i++) {
                                                                                        ResultColumn tableColumn = ((QueryTable) table).getColumns().get(i);
                                                                                        if (tableColumn.hasStarLinkColumn()) {
                                                                                                for (int k = 0; k < tableColumn.getStarLinkColumnList().size(); k++) {
                                                                                                        TObjectName objectName = tableColumn.getStarLinkColumnList().get(k);
                                                                                                        if (DlineageUtil.sameColumnName(columnName, objectName)) {
                                                                                                                ResultColumn resultColumn1 = modelFactory
                                                                                                                                .createResultColumn((QueryTable) table, objectName);
                                                                                                                DataFlowRelationship relation = modelFactory
                                                                                                                                .createDataFlowRelation();
                                                                                                                relation.setEffectType(EffectType.select);
                                                                                                                relation.setTarget(new ResultColumnRelationshipElement(column));
                                                                                                                relation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(resultColumn1));
                                                                                                                pivotedColumns.add(resultColumn1);
                                                                                                                tableColumn.removeStarLinkOf(objectName);
                                                                                                                break;
                                                                                                        }
                                                                                                }
                                                                                        } else if (DlineageUtil.columnMatches(tableColumn, columnName)) {
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(EffectType.select);
                                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                                pivotedColumns.add(tableColumn);
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        } else if (table instanceof Table) {
                                                                                for (TableColumn tableColumn : ((Table) table).getColumns()) {
                                                                                        if (DlineageUtil.columnMatches(tableColumn, columnName)) {
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(EffectType.select);
                                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                pivotedColumns.add(tableColumn);
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        } else if (pivotClause.getPivotInClause().getSubQuery() != null) {
                                                TSelectSqlStatement subquery = pivotClause.getPivotInClause().getSubQuery();
                                                analyzeSelectStmt(subquery);
                                                ResultSet selectSetResultSetModel = (ResultSet) modelManager.getModel(subquery);
                                                for (int j = 0; j < subquery.getResultColumnList().size(); j++) {
                                                        ResultColumn resultColumn = modelFactory.createSelectSetResultColumn(pivotTable,
                                                                        subquery.getResultColumnList().getResultColumn(j), j);
                                                        {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(column));
                                                                relation.addSource(new ResultColumnRelationshipElement(
                                                                                selectSetResultSetModel.getColumns().get(j)));
                                                        }
                                                        {
                                                                for (TObjectName columnName : pivotClause.getPivotColumnList()) {
                                                                        if (table instanceof QueryTable) {
                                                                                for (ResultColumn tableColumn : ((QueryTable) table).getColumns()) {
                                                                                        if (DlineageUtil.columnMatches(tableColumn, columnName)) {
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(EffectType.select);
                                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                                pivotedColumns.add(tableColumn);
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        } else if (table instanceof Table) {
                                                                                for (TableColumn tableColumn : ((Table) table).getColumns()) {
                                                                                        if (DlineageUtil.columnMatches(tableColumn, columnName)) {
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(EffectType.select);
                                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                pivotedColumns.add(tableColumn);
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                        tables.add(pivotTable);
                                        tables.add(table);
                                }
                        }
                }

                TPivotClause pivotClause = pivotClauses.get(0);
                boolean hasAlias = pivotClause.getAliasClause() != null && pivotClause.getAliasClause().getColumns() != null
                                && pivotClause.getAliasClause().getColumns().size() > 0;
                if (hasAlias) {
                        Alias alias = modelFactory.createAlias(pivotClause.getAliasClause());
                        List<TObjectName> aliasColumns = new ArrayList<TObjectName>();
                        int index = 0;
                        for (int k = 0; k < tables.size(); k++) {
                                Object tableItem = tables.get(k);
                                if (tableItem instanceof ResultSet) {
                                        for (ResultColumn tableColumn : ((ResultSet) tableItem).getColumns()) {
                                                if (pivotedColumns.contains(tableColumn)) {
                                                        continue;
                                                }
                                                if (tableColumn.getColumnObject() instanceof TObjectName) {
                                                        aliasColumns.add((TObjectName) tableColumn.getColumnObject());
                                                } else if (tableColumn.getColumnObject() instanceof TResultColumn) {
                                                        if (((TResultColumn) tableColumn.getColumnObject()).getFieldAttr() != null) {
                                                                aliasColumns.add(((TResultColumn) tableColumn.getColumnObject()).getFieldAttr());
                                                        } else {
                                                                TExpression expr = ((TResultColumn) tableColumn.getColumnObject()).getExpr();
                                                                if (expr.getExpressionType() == EExpressionType.simple_constant_t) {
                                                                        TObjectName columnName = new TObjectName();
                                                                        columnName.setString(expr.toString());
                                                                        aliasColumns.add(columnName);
                                                                }
                                                        }
                                                }
                                        }
                                } else if (tableItem instanceof Table) {
                                        for (TableColumn tableColumn : ((Table) tableItem).getColumns()) {
                                                if (pivotedColumns.contains(tableColumn)) {
                                                        continue;
                                                }
                                                aliasColumns.add(index, (TObjectName) tableColumn.getColumnObject());
                                                index++;
                                        }
                                }
                        }

                        IndexedLinkedHashMap<String, ResultColumn> aliasColumnMap = new IndexedLinkedHashMap<String, ResultColumn>();
                        int diffCount = pivotClause.getAliasClause().getColumns().size() -  aliasColumns.size();
                        for (int k = 0; k < pivotClause.getAliasClause().getColumns().size(); k++) {
                                if (pivotClause.getAliasClause().getColumns().size() > aliasColumns.size()) {
                                        if (k < diffCount) {
                                                continue;
                                        }
                                        ResultColumn resultColumn = modelFactory.createResultColumn(alias,
                                                        pivotClause.getAliasClause().getColumns().getObjectName(k));
                                        if ((k - diffCount) < aliasColumns.size()) {
                                                aliasColumnMap.put(aliasColumns.get(k - diffCount).toString(), resultColumn);
                                        }
                                } else {
                                        ResultColumn resultColumn = modelFactory.createResultColumn(alias,
                                                        pivotClause.getAliasClause().getColumns().getObjectName(k));
                                        if (k < aliasColumns.size()) {
                                                aliasColumnMap.put(aliasColumns.get(k).toString(), resultColumn);
                                        }
                                }
                        }

                        for (int k = 0; k < tables.size(); k++) {
                                Object tableItem = tables.get(k);
                                if (tableItem instanceof ResultSet) {
                                        int resultColumnSize = ((ResultSet) tableItem).getColumns().size();
                                        for (int x = 0; x < resultColumnSize; x++) {
                                                ResultColumn tableColumn = ((ResultSet) tableItem).getColumns().get(x);
                                                if (pivotedColumns.contains(tableColumn)) {
                                                        continue;
                                                }
                                                if (tableColumn.getColumnObject() instanceof TObjectName) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.select);
                                                        relation.setTarget(new ResultColumnRelationshipElement(
                                                                        aliasColumnMap.get(tableColumn.getColumnObject().toString())));
                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                } else if (tableColumn.getColumnObject() instanceof TResultColumn) {
                                                        if (((TResultColumn) tableColumn.getColumnObject()).getFieldAttr() != null) {
                                                                ResultColumn targetColumn = aliasColumnMap.get(
                                                                                ((TResultColumn) tableColumn.getColumnObject()).getFieldAttr().toString());
                                                                if(targetColumn == null) {
                                                                        continue;
                                                                }
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                        } else if (((TResultColumn) tableColumn.getColumnObject()).getExpr() != null) {
                                                                TExpression expr = ((TResultColumn) tableColumn.getColumnObject()).getExpr();
                                                                if (expr.getExpressionType() == EExpressionType.simple_constant_t) {
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        ResultColumn targetColumn = (ResultColumn) aliasColumnMap
                                                                                        .getValueAtIndex(aliasColumnMap.size() - resultColumnSize + x);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                }
                                                        }
                                                }
                                        }
                                } else if (tableItem instanceof Table) {
                                        for (TableColumn tableColumn : ((Table) tableItem).getColumns()) {
                                                if (pivotedColumns.contains(tableColumn)) {
                                                        continue;
                                                }
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.select);
                                                relation.setTarget(new ResultColumnRelationshipElement(
                                                                aliasColumnMap.get(tableColumn.getColumnObject().toString())));
                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                        }
                                }
                        }

                        ResultSet resultSet = modelFactory.createResultSet(stmt,
                                        isTopResultSet(stmt) && isShowTopSelectResultSet());
                        TResultColumnList columnList = stmt.getResultColumnList();
                        for (int i = 0; i < columnList.size(); i++) {
                                TResultColumn column = columnList.getResultColumn(i);
                                ResultColumn resultColumn = modelFactory.createAndBindingSelectSetResultColumn(resultSet, column, i);
                                if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                        TResultColumn columnObject = (TResultColumn) resultColumn.getColumnObject();
                                        if (columnObject.getFieldAttr() != null) {
                                                if (DlineageUtil.isStarName((columnObject.getFieldAttr()))) {
                                                        resultColumn.setShowStar(false);
                                                        for (ResultColumn tableColumn : ((ResultSet) alias).getColumns()) {
                                                                resultColumn.bindStarLinkColumn((TObjectName) tableColumn.getColumnObject());
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn, (TObjectName) tableColumn.getColumnObject()));
                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                        }
                                                } else {
                                                        for (ResultColumn tableColumn : ((ResultSet) alias).getColumns()) {
                                                                if (DlineageUtil.columnMatches(tableColumn, columnObject.getFieldAttr())) {
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                        break;
                                                                }
                                                        }
                                                }
                                        } else if (columnObject.getExpr() != null && columnObject.getExpr()
                                                        .getExpressionType() == EExpressionType.sqlserver_proprietary_column_alias_t) {
                                                for (ResultColumn tableColumn : ((ResultSet) alias).getColumns()) {
                                                        if (DlineageUtil.columnMatches(tableColumn, columnObject.getExpr().getRightOperand().getObjectOperand())) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                break;
                                                        }
                                                }
                                        } else if (columnObject.getExpr() != null && columnObject.getExpr()
                                                        .getExpressionType() == EExpressionType.function_t) {
                                                Function function = (Function) createFunction(columnObject.getExpr().getFunctionCall());
                                                for (ResultColumn arg : function.getColumns()) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.select);
                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.addSource(new ResultColumnRelationshipElement(arg));
                                                }
                                        }
                                }
                        }
                } else {
                        ResultSet resultSet = modelFactory.createResultSet(stmt, isTopResultSet(stmt));
                        TResultColumnList columnList = stmt.getResultColumnList();
                        for (int i = 0; i < columnList.size(); i++) {
                                TResultColumn column = columnList.getResultColumn(i);
                                ResultColumn resultColumn = modelFactory.createAndBindingSelectSetResultColumn(resultSet, column, i);
                                if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                        boolean fromFunction = false;
                                        TResultColumn columnObject = (TResultColumn) resultColumn.getColumnObject();
                                        TObjectName resultColumnFieldAttr = columnObject.getFieldAttr();
                                        List<TObjectName> resultColumnNames = new ArrayList<TObjectName>();
                                        if (resultColumnFieldAttr != null) {
                                                resultColumnNames.add(resultColumnFieldAttr);
                                        } else if (columnObject.getExpr() != null
                                                        && column.getExpr().getExpressionType() == EExpressionType.function_t) {
                                                extractFunctionObjectNames(column.getExpr().getFunctionCall(), resultColumnNames);
                                                fromFunction = true;
                                        }
                                        
                                        if (!resultColumnNames.isEmpty()) {
                                                for (TObjectName resultColumnName : resultColumnNames) {
                                                        if (DlineageUtil.isStarName((resultColumnName))) {
                                                                resultColumn.setShowStar(false);
                                                                int index = 0;
                                                                for (int k = 0; k < tables.size(); k++) {
                                                                        Object tableItem = tables.get(k);
                                                                        if (tableItem instanceof ResultSet && !(tableItem instanceof QueryTable)) {
                                                                                for (int x = 0; x < ((ResultSet) tableItem).getColumns().size(); x++) {
                                                                                        ResultColumn tableColumn = ((ResultSet) tableItem).getColumns().get(x);
                                                                                        if (pivotedColumns.contains(tableColumn)) {
                                                                                                continue;
                                                                                        }
                                                                                        if (tableColumn.getColumnObject() instanceof TObjectName) {
                                                                                                resultColumn.bindStarLinkColumn(
                                                                                                                (TObjectName) tableColumn.getColumnObject());
                                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                relation.setEffectType(EffectType.select);
                                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn, (TObjectName) tableColumn.getColumnObject()));
                                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                        } else if (tableColumn.getColumnObject() instanceof TResultColumn) {
                                                                                                if (((TResultColumn) tableColumn.getColumnObject())
                                                                                                                .getFieldAttr() != null) {
                                                                                                        if (tableColumn.hasStarLinkColumn()) {
                                                                                                                for (int z = 0; z < tableColumn.getStarLinkColumnList()
                                                                                                                                .size(); z++) {
                                                                                                                        ResultColumn resultColumn1 = modelFactory
                                                                                                                                        .createResultColumn((ResultSet) tableItem,
                                                                                                                                                        tableColumn.getStarLinkColumnList().get(z));
                                                                                                                        DataFlowRelationship relation = modelFactory
                                                                                                                                        .createDataFlowRelation();
                                                                                                                        relation.setEffectType(EffectType.select);
                                                                                                                        relation.setTarget(
                                                                                                                                        new ResultColumnRelationshipElement(resultColumn));
                                                                                                                        relation.addSource(
                                                                                                                                        new ResultColumnRelationshipElement(resultColumn1));
                                                                                                                        tableColumn.removeStarLinkOf(tableColumn.getStarLinkColumnList().get(z));
                                                                                                                        z--;
                                                                                                                }
                                                                                                        } else {
                                                                                                                resultColumn.bindStarLinkColumn(
                                                                                                                                ((TResultColumn) tableColumn.getColumnObject())
                                                                                                                                                .getFieldAttr());
                                                                                                                DataFlowRelationship relation = modelFactory
                                                                                                                                .createDataFlowRelation();
                                                                                                                relation.setEffectType(EffectType.select);
                                                                                                                relation.setTarget(
                                                                                                                                new ResultColumnRelationshipElement(resultColumn, ((TResultColumn) tableColumn.getColumnObject())
                                                                                                                                                .getFieldAttr()));
                                                                                                                relation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(tableColumn));
                                                                                                        }
                                                                                                } else if (((TResultColumn) tableColumn.getColumnObject())
                                                                                                                .getExpr() != null) {
                                                                                                        TExpression expr = ((TResultColumn) tableColumn.getColumnObject())
                                                                                                                        .getExpr();
                                                                                                        if (expr.getExpressionType() == EExpressionType.simple_constant_t) {
                                                                                                                TObjectName columnName = Column.nameOfText(expr.toString());
                                                                                                                resultColumn.bindStarLinkColumn(columnName);
                                                                                                                DataFlowRelationship relation = modelFactory
                                                                                                                                .createDataFlowRelation();
                                                                                                                relation.setEffectType(EffectType.select);
                                                                                                                relation.setTarget(
                                                                                                                                new ResultColumnRelationshipElement(resultColumn, columnName));
                                                                                                                relation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(tableColumn));
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                }
                                                                        } else if (tableItem instanceof Table) {
                                                                                for (TableColumn tableColumn : ((Table) tableItem).getColumns()) {
                                                                                        if (pivotedColumns.contains(tableColumn)) {
                                                                                                continue;
                                                                                        }
                                                                                        resultColumn.bindStarLinkColumn((TObjectName) tableColumn.getColumnObject(),
                                                                                                        index);
                                                                                        index++;
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.select);
                                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn, (TObjectName) tableColumn.getColumnObject()));
                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                }
                                                                        } else if (tableItem instanceof QueryTable) {
                                                                                for (ResultColumn tableColumn : ((QueryTable) tableItem).getColumns()) {
                                                                                        if (pivotedColumns.contains(tableColumn)) {
                                                                                                continue;
                                                                                        }
                                                                                        TObjectName column1 = copyColumnName(tableColumn, tableColumn.getName());
                                                                                        resultColumn.bindStarLinkColumn(column1, index);
                                                                                        index++;
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.select);
                                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn, column1));
                                                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn), false);
                                                                                }
                                                                        }
                                                                }
                                                        } else {
                                                                ResultColumn pivotedTableColumn = getPivotedTableColumn(pivotedTable, resultColumnName);
                                                                        if (pivotedTableColumn != null) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(pivotedTableColumn));
                                                                        } else {
                                                                                for (int k = 0; k < tables.size(); k++) {
                                                                                        Object tableItem = tables.get(k);
                                                                                        if (tableItem instanceof ResultSet) {
                                                                                                for (ResultColumn tableColumn : ((ResultSet) tableItem).getColumns()) {
                                                                                                        if (DlineageUtil.columnMatches(tableColumn, resultColumnName)) {
                                                                                                                if (fromFunction) {
                                                                                                                        Function function = (Function)createPivotedFunction(column.getExpr().getFunctionCall(), tableColumn);
                                                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                        relation.setEffectType(EffectType.select);
                                                                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                        if (function.getColumns() != null && !function.getColumns().isEmpty()) {
                                                                                                                                for (ResultColumn functionColumn : function.getColumns()) {
                                                                                                                                        relation.addSource(new ResultColumnRelationshipElement(functionColumn));
                                                                                                                                }
                                                                                                                        }
                                                                                                                } else {
                                                                                                                        DataFlowRelationship relation = modelFactory
                                                                                                                                        .createDataFlowRelation();
                                                                                                                        relation.setEffectType(EffectType.select);
                                                                                                                        relation.setTarget(
                                                                                                                                        new ResultColumnRelationshipElement(resultColumn));
                                                                                                                        relation.addSource(
                                                                                                                                        new ResultColumnRelationshipElement(tableColumn));
                                                                                                                }
                                                                                                                break;
                                                                                                        }
                                                                                                }
                                                                                        } else if (tableItem instanceof Table) {
                                                                                                for (TableColumn tableColumn : ((Table) tableItem).getColumns()) {
                                                                                                        if (DlineageUtil.columnMatches(tableColumn, resultColumnName)) {
                                                                                                                DataFlowRelationship relation = modelFactory
                                                                                                                                .createDataFlowRelation();
                                                                                                                relation.setEffectType(EffectType.select);
                                                                                                                relation.setTarget(
                                                                                                                                new ResultColumnRelationshipElement(resultColumn));
                                                                                                                relation.addSource(
                                                                                                                                new TableColumnRelationshipElement(tableColumn));
                                                                                                                break;
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                }
                                        } else if (columnObject.getExpr() != null && columnObject.getExpr()
                                                        .getExpressionType() == EExpressionType.sqlserver_proprietary_column_alias_t) {
                                                for (int k = 0; k < tables.size(); k++) {
                                                        Object tableItem = tables.get(k);
                                                        if (tableItem instanceof ResultSet) {
                                                                for (ResultColumn tableColumn : ((ResultSet) tableItem).getColumns()) {
                                                                        if (columnObject.getExpr().getRightOperand().getObjectOperand() != null
                                                                                        && DlineageUtil.columnMatches(tableColumn, columnObject.getExpr().getRightOperand().getObjectOperand())) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                break;
                                                                        } else if (columnObject.getExpr().getRightOperand()
                                                                                        .getExpressionType() == EExpressionType.function_t) {
                                                                                List<TExpression> expressions = new ArrayList<TExpression>();
                                                                                getFunctionExpressions(expressions, new ArrayList<TExpression>(),
                                                                                                columnObject.getExpr().getRightOperand().getFunctionCall());
                                                                                for (int j = 0; j < expressions.size(); j++) {
                                                                                        columnsInExpr visitor = new columnsInExpr();
                                                                                        expressions.get(j).inOrderTraverse(visitor);
                                                                                        List<TObjectName> objectNames = visitor.getObjectNames();
                                                                                        if (objectNames == null) {
                                                                                                continue;
                                                                                        }
                                                                                        for (TObjectName columnName : objectNames) {
                                                                                                if (DlineageUtil.columnMatches(tableColumn, columnName)) {
                                                                                                        DataFlowRelationship relation = modelFactory
                                                                                                                        .createDataFlowRelation();
                                                                                                        relation.setEffectType(EffectType.select);
                                                                                                        relation.setTarget(
                                                                                                                        new ResultColumnRelationshipElement(resultColumn));
                                                                                                        relation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(tableColumn));
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        } else if (tableItem instanceof Table) {
                                                                for (TableColumn tableColumn : ((Table) tableItem).getColumns()) {
                                                                        if (DlineageUtil.columnMatches(tableColumn, columnObject.getExpr().getRightOperand().getObjectOperand())) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                break;
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }

                analyzeSelectIntoClause(stmt);
        }

        private Function createPivotedFunction(TFunctionCall functionCall, ResultColumn sourceColumn) {
                Function function = modelFactory.createFunction((TFunctionCall) functionCall);
                ResultColumn column = modelFactory.createFunctionResultColumn(function,
                                ((TFunctionCall) functionCall).getFunctionName());
                if ("COUNT".equalsIgnoreCase(builtInFunctionName((TFunctionCall) functionCall))) { // non-identifier-compare: built-in function name
                        // @see https://e.gitee.com/gudusoft/issues/list?issue=I40NUP
                        // COUNT特殊处理，不和参数关联
                        if (option.isShowCountTableColumn()) {
                                analyzePivotedFunctionArgumentsDataFlowRelation(column, functionCall, sourceColumn);
                        }
                } else {
                        analyzePivotedFunctionArgumentsDataFlowRelation(column, functionCall, sourceColumn);
                        Set<Object> functionTableModelObjs = modelManager.getFunctionResults(functionAliasKey(function));
                        if (functionTableModelObjs!=null && functionTableModelObjs.iterator().next() instanceof ResultSet) {
                                ResultSet functionTableModel = (ResultSet) functionTableModelObjs.iterator().next();
                                if (functionTableModel.getColumns() != null) {
                                        for (int j = 0; j < functionTableModel.getColumns().size(); j++) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.select);
                                                        relation.setTarget(new ResultColumnRelationshipElement(column));
                                                        relation.addSource(new ResultColumnRelationshipElement(
                                                                        functionTableModel.getColumns().get(j)));
                                        }
                                }
                        }
                }
                return function;
        }

        private void analyzePivotedFunctionArgumentsDataFlowRelation(ResultColumn column, TFunctionCall functionCall,
                        ResultColumn sourceColumn) {
                List<TExpression> directExpressions = new ArrayList<TExpression>();
                List<TExpression> indirectExpressions = new ArrayList<TExpression>();

                getFunctionExpressions(directExpressions, indirectExpressions, functionCall);

                for (int j = 0; j < directExpressions.size(); j++) {
                        columnsInExpr visitor = new columnsInExpr();
                        directExpressions.get(j).inOrderTraverse(visitor);

                        List<TObjectName> objectNames = visitor.getObjectNames();
                        List<TParseTreeNode> constants = visitor.getConstants();

                        if (objectNames != null) {
                                for (TObjectName name : objectNames) {
                                        if (DlineageUtil.compareColumnIdentifier(name.toString(), sourceColumn.getName())) {
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.select);
                                                relation.setTarget(new ResultColumnRelationshipElement(column));
                                                relation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                        }
                                }
                        }
                        if (constants != null) {
                                for (TParseTreeNode name : constants) {
                                        if (name.toString().equals(sourceColumn.getName())) {
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.select);
                                                relation.setTarget(new ResultColumnRelationshipElement(column));
                                                relation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                        }
                                }
                        }
                }
        }
        
        private void extractFunctionObjectNames(TFunctionCall functionCall, List<TObjectName> resultColumnNames) {
                List<TExpression> directExpressions = new ArrayList<TExpression>();
                List<TExpression> indirectExpressions = new ArrayList<TExpression>();

                getFunctionExpressions(directExpressions, indirectExpressions, functionCall);

                for (int j = 0; j < directExpressions.size(); j++) {
                        columnsInExpr visitor = new columnsInExpr();
                        directExpressions.get(j).inOrderTraverse(visitor);

                        List<TObjectName> objectNames = visitor.getObjectNames();
                        List<TParseTreeNode> functions = visitor.getFunctions();
                        List<TParseTreeNode> constants = visitor.getConstants(); 

                        if (objectNames != null) {
                                resultColumnNames.addAll(objectNames);
                        }
                        
                        if (constants != null) {
                                for(TParseTreeNode item: constants) {
                                        if(item instanceof TConstant && ((TConstant) item).getLiteralType().getText().equals(ELiteralType.string_et.getText())) {
                                                TObjectName object = new TObjectName();
                                                object.setString(item.toString());
                                                resultColumnNames.add(object);
                                        }
                                }
                        }

                        if (functions != null && !functions.isEmpty()) {
                                for (TParseTreeNode function : functions) {
                                        if (function instanceof TFunctionCall) {
                                                extractFunctionObjectNames((TFunctionCall) function, resultColumnNames);
                                        }
                                }
                        }
                }
        }

        private String getResultColumnString(TResultColumn resultColumn) {
                if (resultColumn.getAliasClause() != null) {
                        return resultColumn.getAliasClause().toString();
                }
                return resultColumn.toString();
        }

        /**
         * STRUCT tree: {@code UNNEST(items) AS i} reads the elements of {@code items}, so the unnest table's column
         * {@code i} comes from the array element node {@code items[*]}, and a read of a field of it ({@code i.item_name})
         * binds to {@code items[*].item_name} ({@link ModelFactory#createTableColumn}). The array may itself be a field,
         * {@code UNNEST(customer.orders)}.
         *
         * @return whether the array was found in a table of the analysis
         */
        private boolean linkUnnestElement(Table unnestTable, TTable table, TObjectName arrayColumn) {
                if (arrayColumn.getSourceTable() == null) {
                        return false;
                }
                TTable owner = arrayColumn.getSourceTable();
                if (owner.getCTE() != null || owner.isCTEName() || owner.getSubquery() != null) {
                        // a column of a CTE or a derived table comes from its result set, which the unnest links as before
                        return false;
                }
                Object model = modelManager.getModel(owner);
                if (model == null && owner.getTableType() == ETableSource.objectname) {
                        // without DDL the table is modelled on first use, which may come after its UNNEST
                        model = modelFactory.createTable(owner);
                }
                if (!(model instanceof Table)) {
                        return false;
                }
                TableColumn element = createArrayElement((Table) model, arrayColumn);
                if (element == null) {
                        return false;
                }
                TObjectName elementName = arrayColumn;
                if (table.getAliasClause() != null && table.getAliasClause().getAliasName() != null) {
                        elementName = table.getAliasClause().getAliasName();
                }
                TableColumn unnestColumn = modelFactory.createTableColumn(unnestTable, elementName, true);
                if (unnestColumn == null) {
                        return false;
                }
                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(EffectType.select);
                relation.setTarget(new TableColumnRelationshipElement(unnestColumn));
                relation.addSource(new TableColumnRelationshipElement(element));
                unnestColumn.setSourceColumn(element);
                unnestColumn.setStruct(true);
                return true;
        }

        /**
         * STRUCT tree: the node of the elements of the array {@code arrayColumn} of {@code sourceTable}: {@code items[*]}
         * below the column {@code items}, or {@code payload.items[*]} below the field node {@code payload.items}. Null
         * when the table has no such column.
         */
        private TableColumn createArrayElement(Table sourceTable, TObjectName arrayColumn) {
                TableColumn array = modelFactory.createTableColumn(sourceTable, arrayColumn, false);
                if (array == null) {
                        return null;
                }
                if (!array.getDeclaredFields().isEmpty() && array.getDeclaredElement() == null) {
                        // the DDL declares a STRUCT, not an array: UNNEST of it reads its fields
                        return array;
                }
                List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> segments =
                                new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>();
                if (array.isFieldPathNode()) {
                        segments.addAll(array.getFieldPath().getSegments());
                }
                segments.add(gudusoft.gsqlparser.common.structured.StructuredPathSegment.arrayElement());
                return modelFactory.createFieldPath(array.getDeclaredColumn(), segments, arrayColumn);
        }

        private void analyzeBigQueryUnnest(TSelectSqlStatement stmt, TTable table) {
                Table unnestTable = modelFactory.createTableFromCreateDDL(table, false, getTempTableName(table));
                unnestTable.setSubType(SubType.unnest);
                TUnnestClause clause = table.getUnnestClause();
                TExpression arrayExpr = clause.getArrayExpr();
                if (arrayExpr == null){
                        if (clause.getColumns() != null) {
                                for (TObjectName column : clause.getColumns()) {
                                        // STRUCT tree: the unnest column is the array element; reads of its fields bind to the element's
                                        // field nodes, so no column per field (BigQuery's derived list is the fields the query reads)
                                        if (nestedProfile().buildsDeclaredTree() && linkUnnestElement(unnestTable, table, column)) {
                                                unnestTable.setCreateTable(true);
                                                continue;
                                        }
                                        if (clause.getDerivedColumnList() != null) {
                                                unnestTable.setCreateTable(true);
                                                for (int i = 0; i < clause.getDerivedColumnList().size(); i++) {
                                                        TObjectName columnName = new TObjectName();
                                                        columnName.setString(column.getColumnNameOnly() + "."
                                                                        + clause.getDerivedColumnList().getObjectName(i).getColumnNameOnly());
                                                        TableColumn tableColumn = modelFactory.createTableColumn(unnestTable, columnName, true);
                                                        List<TObjectName> columns = new ArrayList<TObjectName>();
                                                        columns.add(column);
                                                        analyzeDataFlowRelation(tableColumn, columns, EffectType.select, null);
                                                }
                                        }
                                        else {
                                                unnestTable.setCreateTable(true);
                                                boolean find = false;
                                                if (column.getSourceTable() != null && modelManager.getModel(column.getSourceTable()) instanceof Table) {
                                                        Table sourceTable = (Table)modelManager.getModel(column.getSourceTable());
                                                        if(sourceTable!=null) {
                                                                for(TableColumn tableColumn: sourceTable.getColumns()) {
                                                                        if(tableColumn.isStruct()) {
                                                                                List<String> names = SQLUtil.parseNames(tableColumn.getName());
                                                                                if (SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, names.get(0), column.getColumnNameOnly())) {
                                                                                        TObjectName columnName = new TObjectName();
                                                                                        columnName.setString(tableColumn.getName());
                                                                                        TableColumn unnestTableColumn = modelFactory.createTableColumn(unnestTable,
                                                                                                        columnName, true);
                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                        relation.setEffectType(EffectType.select);
                                                                                        relation.setTarget(new TableColumnRelationshipElement(unnestTableColumn));
                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                        find = true;
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                                if (!find) {
                                                        TObjectName colName = column;
                                                        if (table.getAliasClause() != null && table.getAliasClause().getAliasName() != null) {
                                                                colName = table.getAliasClause().getAliasName();
                                                        }
                                                        TableColumn tableColumn = modelFactory.createTableColumn(unnestTable, colName, true);
                                                        // UNNEST(s.items) of a derived table analyzed later in the FROM clause: its result set must
                                                        // exist for the element to link to it (Mantis 4835)
                                                        if (column.getSourceTable() != null && column.getSourceTable().getSubquery() != null
                                                                        && modelManager.getModel(column.getSourceTable()) == null) {
                                                                analyzeTableSubquery(column.getSourceTable());
                                                        }
                                                        List<TObjectName> columns = new ArrayList<TObjectName>();
                                                        columns.add(column);
                                                        analyzeDataFlowRelation(tableColumn, columns, EffectType.select, null);
                                                }
                                        }
                                }
                        }
                        return;
                }
                List<TExpression> expressions = new ArrayList<TExpression>();
                TExpressionList values = arrayExpr.getExprList();
                if (values == null) {
                        expressions.add(arrayExpr);
                }
                else {
                        for(TExpression value: values) {
                                expressions.add(value);
                        }
                }

                for (TExpression value : expressions) {
                        unnestTable.setCreateTable(true);
                        if (value.getExpressionType() == EExpressionType.simple_object_name_t
                                        && nestedProfile().buildsDeclaredTree() && value.getObjectOperand() != null
                                        && linkUnnestElement(unnestTable, table, value.getObjectOperand())) {
                                continue;
                        }
                        if (value.getExpressionType() == EExpressionType.simple_object_name_t) {
                                if (table.getAliasClause() != null) {
                                        TableColumn tableColumn = modelFactory.createTableColumn(unnestTable,
                                                        table.getAliasClause().getAliasName(), true);
                                        columnsInExpr visitor = new columnsInExpr();
                                        value.inOrderTraverse(visitor);
                                        List<TObjectName> columns = visitor.getObjectNames();
                                        analyzeDataFlowRelation(tableColumn, columns, EffectType.select, null);
                                } else {
                                        TResultColumnList resultColumnList = stmt.getResultColumnList();
                                        for (int i = 0; i < resultColumnList.size(); i++) {
                                                TObjectName firstColumn = new TObjectName();
                                                firstColumn.setString(resultColumnList.getResultColumn(0).getColumnNameOnly());
                                                TableColumn tableColumn = modelFactory.createTableColumn(unnestTable, firstColumn, true);
                                                columnsInExpr visitor = new columnsInExpr();
                                                value.inOrderTraverse(visitor);
                                                List<TObjectName> columns = visitor.getObjectNames();
                                                analyzeDataFlowRelation(tableColumn, columns, EffectType.select, null);
                                        }
                                }
                        } else if (value.getExpressionType() == EExpressionType.function_t) {
                                if (table.getAliasClause() != null) {
                                        TableColumn tableColumn = modelFactory.createTableColumn(unnestTable,
                                                        table.getAliasClause().getAliasName(), true);
                                        columnsInExpr visitor = new columnsInExpr();
                                        value.inOrderTraverse(visitor);
                                        List<TParseTreeNode> functions = visitor.getFunctions();
                                        analyzeFunctionDataFlowRelation(tableColumn, functions, EffectType.select, null);
                                } else {
                                        TResultColumnList resultColumnList = stmt.getResultColumnList();
                                        for (int i = 0; i < resultColumnList.size(); i++) {
                                                TObjectName firstColumn = new TObjectName();
                                                firstColumn.setString(resultColumnList.getResultColumn(0).getColumnNameOnly());
                                                TableColumn tableColumn = modelFactory.createTableColumn(unnestTable, firstColumn, true);
                                                columnsInExpr visitor = new columnsInExpr();
                                                value.inOrderTraverse(visitor);
                                                List<TObjectName> columns = visitor.getObjectNames();
                                                analyzeDataFlowRelation(tableColumn, columns, EffectType.select, null);
                                        }
                                }
                        } else if (value.getExpressionType() == EExpressionType.simple_constant_t) {
                                if (table.getAliasClause() != null) {
                                        TableColumn tableColumn = modelFactory.createTableColumn(unnestTable,
                                                        table.getAliasClause().getAliasName(), true);
                                        columnsInExpr visitor = new columnsInExpr();
                                        value.inOrderTraverse(visitor);
                                        List<TParseTreeNode> constants = visitor.getConstants();
                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select, null);
                                } else {
                                        TObjectName firstColumn = new TObjectName();
                                        firstColumn.setString("f0_");
                                        TableColumn tableColumn = modelFactory.createTableColumn(unnestTable, firstColumn, true);
                                        columnsInExpr visitor = new columnsInExpr();
                                        value.inOrderTraverse(visitor);
                                        List<TParseTreeNode> constants = visitor.getConstants();
                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select, null);
                                }
                        } else if (value.getExpressionType() == EExpressionType.list_t) {
                                if (arrayExpr.getTypeName() != null && arrayExpr.getTypeName().getColumnDefList() != null) {
                                        for (int i = 0; i < arrayExpr.getTypeName().getColumnDefList().size(); i++) {
                                                TColumnDefinition column = arrayExpr.getTypeName().getColumnDefList().getColumn(i);
                                                if (column != null && column.getColumnName() != null) {
                                                        TableColumn tableColumn = modelFactory.createTableColumn(unnestTable,
                                                                        column.getColumnName(), true);
                                                        columnsInExpr visitor = new columnsInExpr();
                                                        value.getExprList().getExpression(i).inOrderTraverse(visitor);
                                                        List<TParseTreeNode> constants = visitor.getConstants();
                                                        analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select, null);
                                                }
                                        }
                                } else {
                                        for (int i = 0; i < value.getExprList().size(); i++) {
                                                TObjectName firstColumn = new TObjectName();
                                                firstColumn.setString("f" + i + "_");
                                                TableColumn tableColumn = modelFactory.createTableColumn(unnestTable, firstColumn, true);
                                                columnsInExpr visitor = new columnsInExpr();
                                                value.getExprList().getExpression(i).inOrderTraverse(visitor);
                                                List<TParseTreeNode> constants = visitor.getConstants();
                                                analyzeConstantDataFlowRelation(tableColumn, constants, EffectType.select, null);
                                        }
                                }
                        } else if (value.getExpressionType() == EExpressionType.subquery_t) {
                                analyzeSelectStmt(value.getSubQuery());
                                ResultSet resultSet = (ResultSet) modelManager.getModel(value.getSubQuery());
                                if (resultSet != null) {
                                        for (int i = 0; i < resultSet.getColumns().size(); i++) {
                                                TObjectName columnName =  new TObjectName();
                                                if(resultSet.getColumns().get(i).getAlias()!=null) {
                                                        columnName.setString(resultSet.getColumns().get(i).getAlias());
                                                }
                                                else {
                                                        ResultColumn subqueryColumn = resultSet.getColumns().get(i);
                                                        String segment = DlineageUtil.columnSegmentOf(subqueryColumn.getName());
                                                        // a column the subquery names takes that name as written, as an alias does above; an
                                                        // anonymous expression (ARRAY_AGG(t.x)) has no name, and keeps the display it always had
                                                        columnName.setString(subqueryColumn.getIdentifierKey() != null ? segment
                                                                        : LegacyDlineageWireNamesV1.columnName(segment));
                                                }
                                                TableColumn tableColumn = modelFactory.createTableColumn(unnestTable, columnName, true);
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.select);
                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                relation.addSource(
                                                                new ResultColumnRelationshipElement(resultSet.getColumns().get(i)));
                                        }
                                }
                        }
                }
                if (unnestTable.getColumns().isEmpty() && table.getAliasClause() != null
                                && table.getAliasClause().getAliasName() != null) {
                        // an array none of whose items made a column (an empty array, UNNEST(ARRAY<INT64>[]) AS x): no rows, but
                        // still the column x the query selects; without it the select list lost x (plan 09 slice 11)
                        unnestTable.setCreateTable(true);
                        modelFactory.createTableColumn(unnestTable, table.getAliasClause().getAliasName(), true);
                }
        }

        /**
         * Trino and Athena {@code UNNEST(a, b) [WITH ORDINALITY] AS t(x, y[, n])}: links each alias column of the unnest
         * table to the array it reads, found through the resolver's binding of the argument (a column of a physical
         * table, of a CTE or of a derived table), so the owner need not be the first FROM item. An alias reads the
         * argument at its position when the counts agree, every alias reads the one argument's element when there is a
         * single argument (an ARRAY(ROW) expands into one alias per field), and with several arguments and a different
         * number of aliases no edge is published, because the mapping needs the element types. The ordinality alias
         * reads every array whole: its value depends on their cardinalities, not on any element. Nothing is linked for an
         * expression argument, {@code UNNEST(sequence(1, n))}, whose value is not an array column (Mantis 4826).
         */
        private void analyzeTrinoUnnest(TTable table) {
                TUnnestClause clause = table.getUnnestClause();
                Table unnestTable = modelFactory.createTable(table);
                if (unnestTable == null) {
                        return;
                }
                unnestTable.setSubType(SubType.unnest);
                TObjectNameList arguments = clause.getColumns();
                TObjectNameList aliases = table.getAliasClause() != null ? table.getAliasClause().getColumns() : null;
                if (arguments == null || arguments.size() == 0 || aliases == null || aliases.size() == 0) {
                        return;
                }
                int argCount = arguments.size();
                int aliasCount = aliases.size();
                boolean ordinality = clause.isWithOrdinality();
                int valueAliases = ordinality ? aliasCount - 1 : aliasCount;
                for (int i = 0; i < aliasCount; i++) {
                        TableColumn targetColumn = modelFactory.createTableColumn(unnestTable, aliases.getObjectName(i), true);
                        if (targetColumn == null) {
                                continue;
                        }
                        List<Object> sources = new ArrayList<Object>();
                        if (ordinality && i == aliasCount - 1) {
                                for (int a = 0; a < argCount; a++) {
                                        Object source = unnestArgumentSource(arguments.getObjectName(a), false);
                                        if (source != null) {
                                                sources.add(source);
                                        }
                                }
                        } else {
                                int argIndex = argCount == valueAliases ? i : argCount == 1 ? 0 : -1;
                                Object source = argIndex >= 0 ? unnestArgumentSource(arguments.getObjectName(argIndex), true) : null;
                                if (source != null) {
                                        sources.add(source);
                                }
                        }
                        for (Object source : sources) {
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.select);
                                relation.setTarget(new TableColumnRelationshipElement(targetColumn));
                                if (source instanceof TableColumn) {
                                        relation.addSource(new TableColumnRelationshipElement((TableColumn) source));
                                } else {
                                        relation.addSource(new ResultColumnRelationshipElement((ResultColumn) source));
                                }
                        }
                }
        }

        /** The position of {@code column} in the derived column list of {@code table}, {@code d(a, xs)}; -1 when absent. */
        private int derivedColumnPosition(TTable table, TObjectName column) {
                if (table.getAliasClause() == null || table.getAliasClause().getColumns() == null) {
                        return -1;
                }
                TObjectNameList columns = table.getAliasClause().getColumns();
                for (int i = 0; i < columns.size(); i++) {
                        if (DlineageUtil.sameColumnName(columns.getObjectName(i), column)) {
                                return i;
                        }
                }
                return -1;
        }

        /**
         * The model an UNNEST argument reads, through the resolver's binding of the column: for a CTE or derived-table
         * owner its result column; for a physical table the element node of the array ({@code items[*]}) when
         * {@code element}, else the array column itself. Null when the argument is unbound.
         */
        private Object unnestArgumentSource(TObjectName argument, boolean element) {
                TTable owner = argument.getSourceTable();
                if (owner == null) {
                        return null;
                }
                if (owner.getCTE() != null || owner.isCTEName() || owner.getSubquery() != null) {
                        if (owner.getSubquery() != null && modelManager.getModel(owner) == null) {
                                // a derived table analyzed later in the FROM clause: its result set must exist to link to it
                                analyzeTableSubquery(owner);
                        }
                        Object model = modelManager.getModel(owner);
                        if (!(model instanceof ResultSet) && owner.getSubquery() != null) {
                                model = modelManager.getModel(owner.getSubquery());
                        }
                        if (model instanceof ResultSet) {
                                return matchResultColumn(((ResultSet) model).getColumns(), argument);
                        }
                        return null;
                }
                Object model = modelManager.getModel(owner);
                if (model == null && owner.getTableType() == ETableSource.objectname) {
                        model = modelFactory.createTable(owner);
                }
                if (!(model instanceof Table)) {
                        return null;
                }
                if (element && nestedProfile().buildsDeclaredTree()) {
                        TableColumn elementNode = createArrayElement((Table) model, argument);
                        if (elementNode != null) {
                                return elementNode;
                        }
                }
                return modelFactory.createTableColumn((Table) model, argument, true);
        }

        private void analyzePrestoUnnest(TSelectSqlStatement stmt, TTable table) {
                List<Table> tables = new ArrayList<Table>();
                TTable targetTable = stmt.getTables().getTable(0);
                SqllrObservations decided = SqllrObservations.current();
                if (decided != null) {
                        decided.decision(SqllrObservations.DECISION_UNNEST_FIRST_TABLE, null, targetTable,
                                        "the array of an UNNEST read from the first FROM item");
                }
                Table stmtTable = null;
                Object sourceTable = null;
                if (targetTable.getSubquery() == null && (targetTable.isCTEName() || targetTable.getCTE() != null)) {
                        // a CTE reference: the result set of its body is the source of the unnested array, and no physical table
                        // is modelled under the CTE's name (Mantis 4826)
                        Object cteModel = modelManager.getModel(targetTable);
                        TSelectSqlStatement body = targetTable.getCTE() != null ? targetTable.getCTE().getSubquery() : null;
                        if (!(cteModel instanceof ResultSet) && body != null) {
                                if (!stmtStack.contains(body) && modelManager.getModel(body) == null
                                                && (body.getResultColumnList() == null || modelManager.getModel(body.getResultColumnList()) == null)) {
                                        analyzeSelectStmt(body);
                                }
                                cteModel = body.isCombinedQuery() || body.getResultColumnList() == null ? modelManager.getModel(body)
                                                : modelManager.getModel(body.getResultColumnList());
                        }
                        if (cteModel instanceof ResultSet) {
                                sourceTable = cteModel;
                        }
                } else if (targetTable.getSubquery() == null || targetTable.getSubquery().getValueClause() != null) {
                        // a physical table, or a VALUES list whose rows the unnest reads by the derived column list; a SELECT
                        // derived table is read through its result set and no physical table is modelled under its alias
                        stmtTable = modelFactory.createTable(targetTable);
                }
                if (targetTable.getSubquery() != null) {
                        analyzeSelectStmt(targetTable.getSubquery());
                        if (targetTable.getSubquery().isCombinedQuery()) {
                                ResultSet sourceResultSet = (ResultSet) modelManager.getModel(targetTable.getSubquery());
                                sourceTable = sourceResultSet;
                        } else if (targetTable.getSubquery().getResultColumnList() != null) {
                                ResultSet sourceResultSet = (ResultSet) modelManager
                                                .getModel(targetTable.getSubquery().getResultColumnList());
                                sourceTable = sourceResultSet;
                        } else if (targetTable.getSubquery().getValueClause() != null) {
                                List<TResultColumnList> rowList = targetTable.getSubquery().getValueClause().getRows();
                                if (rowList != null && rowList.size() > 0) {
                                        Table valuesTable = modelFactory.createTableByName("Values-Table", true);
                                        int columnCount = rowList.get(0).size();
                                        for (int j = 1; j <= columnCount; j++) {
                                                TObjectName columnName = new TObjectName();
                                                TResultColumn columnObject = rowList.get(0).getResultColumn(j - 1);
                                                if (columnObject.getExpr().getExpressionType() == EExpressionType.typecast_t) {
                                                        columnName.setString(columnObject.getExpr().getLeftOperand().toString());
                                                } else {
                                                        columnName.setString(columnObject.getExpr().toString());
                                                }
                                                modelFactory.createTableColumn(valuesTable, columnName, true);
                                        }
                                        valuesTable.setCreateTable(true);
                                        valuesTable.setSubType(SubType.values_table);
                                        sourceTable = valuesTable;
                                }
                        }
                }
                if (stmtTable != null) {
                        tables.add(stmtTable);
                }
                Table unnestTable = modelFactory.createTable(table);
                unnestTable.setSubType(SubType.unnest);
                tables.add(unnestTable);
                if (table.getAliasClause() != null && table.getAliasClause().getColumns() != null
                                && table.getUnnestClause().getColumns() != null) {
                        TObjectNameList arguments = table.getUnnestClause().getColumns();
                        TObjectNameList aliases = table.getAliasClause().getColumns();
                        int argCount = arguments.size();
                        int aliasCount = aliases.size();
                        // UNNEST(a, b) WITH ORDINALITY AS t(x, y, n): the last alias is the 1-based position (Mantis 4826)
                        boolean ordinality = table.getUnnestClause().isWithOrdinality();
                        int valueAliases = ordinality ? aliasCount - 1 : aliasCount;
                        for (int i = 0; i < aliasCount; i++) {
                                boolean ordinal = ordinality && i == aliasCount - 1;
                                // Which argument an alias reads: by position when the counts agree; a single argument gives every
                                // alias (Trino expands an ARRAY(ROW) argument into one alias per field); with several arguments and a
                                // different number of aliases the mapping needs the element types, so no edge is published.
                                int argIndex = -1;
                                if (!ordinal) {
                                        if (argCount == valueAliases) {
                                                argIndex = i;
                                        } else if (argCount == 1) {
                                                argIndex = 0;
                                        }
                                }
                                TableColumn sourceColumn = null;
                                ResultColumn sourceResultColumn = null;
                                List<TableColumn> ordinalSources = new ArrayList<TableColumn>();
                                if (ordinal) {
                                        // the 1-based position: it depends on every array's cardinality (the longest sets the row count)
                                        for (int a = 0; a < argCount && stmtTable != null; a++) {
                                                TableColumn array = modelFactory.createTableColumn(stmtTable, arguments.getObjectName(a), true);
                                                if (array != null) {
                                                        ordinalSources.add(array);
                                                }
                                        }
                                } else if (argIndex >= 0) {
                                        TObjectName argument = arguments.getObjectName(argIndex);
                                        if (sourceTable == null && stmtTable != null && nestedProfile().buildsDeclaredTree()) {
                                                // STRUCT tree: the column comes from the elements of the array it unnests, payload.items[*]
                                                sourceColumn = createArrayElement(stmtTable, argument);
                                        }
                                        if (stmtTable == null && sourceTable instanceof ResultSet) {
                                                // the array is a column of the CTE or derived table: the unnest column reads that result column
                                                sourceResultColumn = matchResultColumn(((ResultSet) sourceTable).getColumns(), argument);
                                        }
                                        if (sourceColumn == null && stmtTable != null) {
                                                sourceColumn = modelFactory.createTableColumn(stmtTable, argument, true);
                                                // the VALUES column the argument names: its position in the derived column list, d(xs)
                                                if (sourceTable instanceof Table) {
                                                        int position = derivedColumnPosition(targetTable, argument);
                                                        if (position >= 0 && position < ((Table) sourceTable).getColumns().size()) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new TableColumnRelationshipElement(sourceColumn));
                                                                relation.addSource(
                                                                                new TableColumnRelationshipElement(((Table) sourceTable).getColumns().get(position)));
                                                        }
                                                } else if (sourceTable instanceof ResultSet) {
                                                        ResultColumn candidate = matchResultColumn(((ResultSet) sourceTable).getColumns(), argument);
                                                        if (candidate != null) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new TableColumnRelationshipElement(sourceColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(candidate));
                                                        }
                                                }
                                        }
                                }
                                TableColumn targetColumn = modelFactory.createTableColumn(unnestTable, aliases.getObjectName(i), true);
                                if (sourceColumn != null) {
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(EffectType.select);
                                        relation.setTarget(new TableColumnRelationshipElement(targetColumn));
                                        relation.addSource(new TableColumnRelationshipElement(sourceColumn));
                                } else if (sourceResultColumn != null) {
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(EffectType.select);
                                        relation.setTarget(new TableColumnRelationshipElement(targetColumn));
                                        relation.addSource(new ResultColumnRelationshipElement(sourceResultColumn));
                                }
                                for (TableColumn array : ordinalSources) {
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(EffectType.select);
                                        relation.setTarget(new TableColumnRelationshipElement(targetColumn));
                                        relation.addSource(new TableColumnRelationshipElement(array));
                                }
                        }
                }

                ResultSet resultSet = modelFactory.createResultSet(stmt,
                                isTopResultSet(stmt) && isShowTopSelectResultSet());
                TResultColumnList columnList = stmt.getResultColumnList();
                for (int i = 0; i < columnList.size(); i++) {
                        TResultColumn column = columnList.getResultColumn(i);
                        ResultColumn resultColumn = modelFactory.createSelectSetResultColumn(resultSet, column, i);
                        if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                TResultColumn columnObject = (TResultColumn) resultColumn.getColumnObject();
                                if (columnObject.getFieldAttr() != null) {
                                        if (DlineageUtil.isStarName((columnObject.getFieldAttr()))) {
                                                for (int k = 0; k < tables.size(); k++) {
                                                        Table tableItem = tables.get(k);
                                                        for (TableColumn tableColumn : tableItem.getColumns()) {
                                                                resultColumn.bindStarLinkColumn(tableColumn.getColumnObject());
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn, tableColumn.getColumnObject()));
                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                        }
                                                }
                                        } else {
                                                boolean match = false;
                                                TObjectName read = columnObject.getFieldAttr();
                                                // a field of an unnest column, sites.hostname with UNNEST(items) t(sites): the read is of the
                                                // column sites, named by the base token of the field path (Mantis 4826)
                                                String readColumn = read.getFieldPathRead() != null && read.getFieldPathBaseToken() != null
                                                                ? read.getFieldPathBaseToken().toString() : null;
                                                for (int k = 0; k < tables.size(); k++) {
                                                        Table tableItem = tables.get(k);
                                                        for (TableColumn tableColumn : tableItem.getColumns()) {
                                                                boolean matches = readColumn != null ? DlineageUtil.columnMatches(tableColumn, readColumn)
                                                                                : DlineageUtil.columnMatches(tableColumn, read);
                                                                if (matches) {
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                        match = true;
                                                                }
                                                        }
                                                }
                                                if (!match && stmtTable == null && sourceTable instanceof ResultSet) {
                                                        // a column of the CTE the unnest reads from (Mantis 4826)
                                                        ResultColumn cteColumn = matchResultColumn(((ResultSet) sourceTable).getColumns(), read);
                                                        if (cteColumn != null) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(cteColumn));
                                                                match = true;
                                                        }
                                                }
                                                if (!match && stmtTable != null) {
                                                        TableColumn tableColumn = modelFactory.createTableColumn(stmtTable, read, false);
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.select);
                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                }
                                        }
                                }
                        }
                }
        }

        /**
         * Plan section 4.3: a Hive-family {@code LATERAL VIEW f(args) lv AS c1, c2} is one more relation of its SELECT.
         * <ul>
         *   <li>its table is the view's own ({@link ModelFactory#createArrayRelationTable}), never a table of the script
         *       that happens to have the alias's name (Mantis 4890);</li>
         *   <li>the function is a node of its own, fed by its arguments, which TSQLResolver2 resolved against the
         *       relations to the view's left, an earlier LATERAL VIEW included (Mantis 4888, 4889);</li>
         *   <li>each column alias is a column of the view, fed by the function;</li>
         *   <li>for a function proven to produce the elements of its argument (role ELEMENT, {@link #lateralViewElementRole}),
         *       the element column is linked to the argument's element node ({@code items[*]}), so a read of it or of a
         *       field of it reads that node ({@code ModelFactory.createUnnestElementRead}).</li>
         * </ul>
         * The select list, the WHERE clause, joins and the rest are then analyzed by the general flow, the view being a
         * relation like any other (Mantis 4887).
         */
        private void analyzeLateralViewRelation(TTable table) {
                TLateralView view = table.getLateralView();
                TFunctionCall udtf = view == null ? null : view.getUdtf();
                String name = table.getAliasClause() != null && table.getAliasClause().getAliasName() != null
                                ? table.getAliasClause().getAliasName().toString()
                                : (udtf != null ? udtf.toString() : table.getName());
                Table shared = view == null ? null : lateralViewRelations.get(view);
                if (shared != null) {
                        // the FROM clause of a Hive multi-insert serves every INSERT: each body holds its own copy of the view's
                        // table, all of one TLateralView, and they are one relation (Codex review of phase 3)
                        if (modelManager.getBoundModel(table) == null) {
                                modelManager.bindModel(table, shared);
                        }
                        return;
                }
                Table relation = modelManager.getBoundModel(table) instanceof Table ? (Table) modelManager.getBoundModel(table)
                                : modelFactory.createArrayRelationTable(table, arrayRelationName(name));
                if (view != null) {
                        lateralViewRelations.put(view, relation);
                }
                if (udtf == null) {
                        return;
                }
                Function function = modelFactory.createFunction(udtf);
                ResultColumn functionColumn = modelFactory.createFunctionResultColumn(function, udtf.getFunctionName());
                for (int i = 0; udtf.getArgs() != null && i < udtf.getArgs().size(); i++) {
                        TExpression argument = udtf.getArgs().getExpression(i);
                        if (argument == null) {
                                continue;
                        }
                        columnsInExpr visitor = new columnsInExpr();
                        argument.inOrderTraverse(visitor);
                        List<TParseTreeNode> functions = visitor.getFunctions();
                        if (functions != null && !functions.isEmpty()) {
                                analyzeFunctionDataFlowRelation(functionColumn, functions, EffectType.function);
                        }
                        List<TSelectSqlStatement> subqueries = visitor.getSubquerys();
                        if (subqueries != null && !subqueries.isEmpty()) {
                                analyzeSubqueryDataFlowRelation(functionColumn, subqueries, EffectType.select);
                        }
                        List<TObjectName> unresolved = new ArrayList<TObjectName>();
                        List<RelationshipElement<?>> inputs = new ArrayList<RelationshipElement<?>>();
                        for (TObjectName input : visitor.getObjectNames()) {
                                if (!linkLateralViewInput(input, inputs)) {
                                        unresolved.add(input);
                                }
                        }
                        if (!inputs.isEmpty()) {
                                DataFlowRelationship inputRelation = modelFactory.createDataFlowRelation();
                                inputRelation.setEffectType(EffectType.select);
                                inputRelation.setTarget(new ResultColumnRelationshipElement(functionColumn));
                                for (RelationshipElement<?> input : inputs) {
                                        inputRelation.addSource(input);
                                }
                                addRelationRowsImpacts(inputRelation, EffectType.select);
                        }
                        analyzeDataFlowRelation(functionColumn, unresolved, EffectType.select, functions);
                        analyzeConstantDataFlowRelation(functionColumn, visitor.getConstants(), EffectType.select, functions);
                }
                int element = lateralViewElementRole(view, udtf);
                for (int j = 0; view.getColumnAliasList() != null && j < view.getColumnAliasList().size(); j++) {
                        TableColumn column = modelFactory.createTableColumn(relation, view.getColumnAliasList().getObjectName(j),
                                        true);
                        if (column == null) {
                                continue;
                        }
                        DataFlowRelationship relationship = modelFactory.createDataFlowRelation();
                        relationship.setEffectType(EffectType.select);
                        relationship.setTarget(new TableColumnRelationshipElement(column));
                        relationship.addSource(new ResultColumnRelationshipElement(functionColumn));
                        if (j == element) {
                                linkLateralViewElement(column, udtf.getArgs().getExpression(0));
                        }
                }
        }

        /**
         * Plan section 4.3: adds to {@code inputs} the source of {@code input}, a column the arguments of a LATERAL VIEW's
         * function read, by the relation TSQLResolver2 resolved it to among the relations to the view's left: a table, an
         * earlier view, a CTE or a derived table. An input the resolver found in none of them reads nothing: the
         * statement's other relations are to the right, and matching one of them by name would publish an edge the SQL
         * does not have (Codex review of phase 2).
         *
         * @return false when the resolver gave no verdict on {@code input} (a variable, or no resolution), for the general
         *         path; true when the input is handled, linked or refused
         */
        private boolean linkLateralViewInput(TObjectName input, List<RelationshipElement<?>> inputs) {
                if (input.getDbObjectType() == EDbObjectType.variable || input.getResolution() == null) {
                        return false;
                }
                TTable source = input.getSourceTable();
                if (source == null) {
                        return true;
                }
                Object model = modelManager.getModel(source);
                if (model instanceof Table) {
                        TableColumn column = modelFactory.createTableColumn((Table) model, input, false);
                        if (column != null) {
                                inputs.add(new TableColumnRelationshipElement(column, input.getLocation(), input));
                        }
                        return true;
                }
                if (!(model instanceof ResultSet)) {
                        return false;
                }
                List<ResultColumn> columns = ((ResultSet) model).getColumns();
                ResultColumn column = structFieldReadSource(structFieldReadBaseColumn(input, columns), input);
                for (int k = 0; column == null && k < columns.size(); k++) {
                        if (!columns.get(k).isStarColumn() && referencesColumn(input, columns.get(k))) {
                                column = columns.get(k);
                        }
                }
                for (int k = 0; column == null && k < columns.size(); k++) {
                        if (columns.get(k).isStarColumn()) {
                                column = columns.get(k);
                                if (!containsStarColumn(column, input)) {
                                        column.bindStarLinkColumn(input);
                                }
                        }
                }
                if (column != null) {
                        inputs.add(new ResultColumnRelationshipElement(column, input));
                }
                return true;
        }

        /** The relation of each LATERAL VIEW modelled, so the copies of a multi-insert's view share one. */
        private final Map<TLateralView, Table> lateralViewRelations = new IdentityHashMap<TLateralView, Table>();

        /** The parser of the unit being analyzed ({@link #recordStatementOrdinals}). */
        private TGSqlParser unitParser;

        /** The identity keys of the tables the unit's statements name, made on first use. */
        private Set<Object> unitTableNames;

        /**
         * The identity keys of every table a statement of the unit names, a later statement's included: a LATERAL VIEW's
         * relation must not publish the name of a table the script reads after it (Codex review of phase 2).
         */
        private Set<Object> unitTableNames() {
                if (unitTableNames == null) {
                        final Set<Object> names = new HashSet<Object>();
                        for (int i = 0; unitParser != null && i < unitParser.getSqlstatements().size(); i++) {
                                unitParser.getSqlstatements().get(i).acceptChildren(new TParseTreeVisitor() {
                                        @Override
                                        public void preVisit(TTable table) {
                                                if (table.getTableType() == ETableSource.objectname && !table.isCTEName()
                                                                && table.getTableName() != null) {
                                                        names.add(DlineageUtil.getTableIdentityKey(table.getTableName().toString()));
                                                }
                                        }
                                });
                        }
                        unitTableNames = names;
                }
                return unitTableNames;
        }

        /** The published names of the relations LATERAL VIEWs added, by identity key. */
        private final Set<Object> arrayRelationNames = new HashSet<Object>();

        /**
         * The name a LATERAL VIEW's relation publishes: its alias, numbered ({@code tmp1-1}, {@code tmp1-2}) when a table
         * of the script or an earlier view already has that name, so two relations never share one (Mantis 4845, 4890).
         */
        private String arrayRelationName(String alias) {
                String name = alias;
                for (int k = 1; modelManager.getTableByName(DlineageUtil.getTableIdentityKey(name)) != null
                                || arrayRelationNames.contains(DlineageUtil.getTableIdentityKey(name))
                                || unitTableNames().contains(DlineageUtil.getTableIdentityKey(name)); k++) {
                        name = alias + "-" + k;
                }
                arrayRelationNames.add(DlineageUtil.getTableIdentityKey(name));
                return name;
        }

        /**
         * Plan section 4.3, role proof: which column alias of a LATERAL VIEW is the element of the function's argument,
         * or -1. Only an unqualified {@code explode} or {@code explode_outer} of one argument with one alias proves it (the
         * rule of Mantis 4845); any other function ({@code posexplode}, {@code inline}, a UDTF), a qualified one
         * ({@code my_schema.explode}), another arity, or an argument the DDL declares as a MAP keeps every alias fed by the
         * whole argument through the function.
         */
        private int lateralViewElementRole(TLateralView view, TFunctionCall udtf) {
                if (!nestedProfile().buildsDeclaredTree() || udtf.getFunctionName() == null
                                || udtf.getFunctionName().getSchemaToken() != null || udtf.getFunctionName().getDatabaseToken() != null
                                || udtf.getArgs() == null || udtf.getArgs().size() != 1 || view.getColumnAliasList() == null) {
                        return -1;
                }
                String function = udtf.getFunctionName().toString();
                int aliases = view.getColumnAliasList().size();
                if (("explode".equalsIgnoreCase(function) || "explode_outer".equalsIgnoreCase(function)) && aliases == 1) { // non-identifier-compare: built-in function name
                        return 0;
                }
                return -1;
        }

        /**
         * Links {@code column}, the element alias of a LATERAL VIEW, to the element node of the function's argument
         * ({@code items[*]} of {@code events.items}, or {@code items[*].subs[*]} when the argument is a field of an earlier
         * view's element). The argument must be one column the resolver placed, of a table or of another view; the
         * column of a CTE or a derived table has no element node, and a declared MAP has no element.
         */
        private void linkLateralViewElement(TableColumn column, TExpression argument) {
                if (argument == null || argument.getExpressionType() != EExpressionType.simple_object_name_t
                                || argument.getObjectOperand() == null || argument.getObjectOperand().getSourceTable() == null) {
                        return;
                }
                TObjectName array = argument.getObjectOperand();
                Object owner = modelManager.getModel(array.getSourceTable());
                if (!(owner instanceof Table)) {
                        return;
                }
                TableColumn arrayNode = modelFactory.createTableColumn((Table) owner, array, false);
                if (arrayNode == null || arrayNode.getDeclaredKind() == gudusoft.gsqlparser.common.structured.DeclaredTypeNode.Kind.MAP) {
                        return;
                }
                TableColumn element = createArrayElement((Table) owner, array);
                if (element == null || !element.isFieldPathNode() || element.getFieldPath().getSegments().get(
                                element.getFieldPath().getSegments().size() - 1).getKind()
                                != gudusoft.gsqlparser.common.structured.StructuredPathSegmentKind.ARRAY_ELEMENT) {
                        return;
                }
                // not a STRUCT field of its source: the simple output's struct test would drop lv2.sub <- items[*].subs
                column.setSourceColumn(element);
        }

        private boolean isFromFunction(TObjectName object) {

                Stack<TParseTreeNode> nodes = object.getStartToken().getNodesStartFromThisToken();
                if (nodes != null) {
                        for (int i = 0; i < nodes.size(); i++) {
                                if (nodes.get(i) instanceof TFunctionCall) {
                                        return true;
                                }
                        }
                }
                return false;
        }

        private TResultColumnList getResultColumnList(TSelectSqlStatement stmt) {
                // Iterative DFS (left-first) to find the first non-combined query's result column list.
                // Avoids StackOverflow with deeply nested UNION trees.
                Deque<TSelectSqlStatement> stack = new ArrayDeque<>();
                stack.push(stmt);
                while (!stack.isEmpty()) {
                        TSelectSqlStatement current = stack.pop();
                        if (current.isCombinedQuery()) {
                                // Push right first so left is processed first (stack is LIFO)
                                if (current.getRightStmt() != null) stack.push(current.getRightStmt());
                                if (current.getLeftStmt() != null) stack.push(current.getLeftStmt());
                        } else {
                                if (current.getResultColumnList() != null) {
                                        return current.getResultColumnList();
                                }
                        }
                }
                return null;
        }

        private void createPseudoImpactRelation(TCustomSqlStatement stmt, ResultSet resultSetModel, EffectType effectType) {
                if (stmt.getTables() != null) {
                        for (int i = 0; i < stmt.getTables().size(); i++) {
                                TTable table = stmt.getTables().getTable(i);
                                if (modelManager.getModel(table) instanceof ResultSet) {
                                        ResultSet tableModel = (ResultSet) modelManager.getModel(table);
                                        if (tableModel != resultSetModel && !tableModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(effectType);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                tableModel.getRelationRows()));
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                resultSetModel.getRelationRows()));
                                        }
                                } else if (modelManager.getModel(table) instanceof Table) {
                                        Table tableModel = (Table) modelManager.getModel(table);
                                        if (!tableModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(effectType);
                                                impactRelation.addSource(
                                                                new RelationRowsRelationshipElement<TableRelationRows>(tableModel.getRelationRows()));
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                resultSetModel.getRelationRows()));
                                        }
                                }
                        }
                }
        }

        private void analyzeFunctionDataFlowRelation(Object gspObject, List<TParseTreeNode> functions,
                        EffectType effectType) {
                for (int i = 0; i < functions.size(); i++) {
                        TParseTreeNode functionCall = functions.get(i);
                        if (functionCall instanceof TFunctionCall) {
                                Procedure procedure = modelManager.getProcedure(callAliasKey((TFunctionCall) functionCall));
                                if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("functionRelation3", ((TFunctionCall) functionCall).getFunctionName(), procedure,
                                                new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf((TFunctionCall) functionCall)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.FUNCTION);
                                if (procedure != null) {
                                        String procedureParent = getProcedureParentName(stmtStack.peek());
                                        if (procedureParent != null) {
                                                Procedure caller = getEnclosingProcedure(stmtStack.peek());
                                                if (caller != null) {
                                                        CallRelationship callRelation = modelFactory.createCallRelation();
                                                        callRelation.setCallObject(functionCall);
                                                        callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                        callRelation.addSource(new ProcedureRelationshipElement(procedure));
                                                        if (isBuiltInFunctionName(((TFunctionCall)functionCall).getFunctionName())||isKeyword(((TFunctionCall)functionCall).getFunctionName())) {
                                                                callRelation.setBuiltIn(true);
                                                        }
                                                }
                                        }
                                        if (procedure.getProcedureObject() instanceof TCreateFunctionStmt) {
                                                TCreateFunctionStmt createFunction = (TCreateFunctionStmt)procedure.getProcedureObject();
                                                TTypeName dataType = createFunction.getReturnDataType();
                                                if (dataType!=null && dataType.getTypeOfList() != null && dataType.getTypeOfList().getColumnDefList() != null) {
                                                        Object modelObject = modelManager.getModel(gspObject);
                                                        if(modelObject instanceof ResultColumn) {
                                                                ResultColumn resultColumn = (ResultColumn)modelObject;
                                                                ResultSet resultSet = resultColumn.getResultSet();
                                                                for (int j = 0; j < dataType.getTypeOfList().getColumnDefList().size(); j++) {
                                                                        TObjectName columnName = new TObjectName();
                                                                        if( dataType.getDataType() == EDataType.array_t) {
//                                                                              columnName.setString(resultColumn.getName() + ".array."
//                                                                                              + dataType.getTypeOfList().getColumnDefList().getColumn(j)
//                                                                                                              .getColumnName().getColumnNameOnly());
                                                                                columnName.setString(resultColumn.getName() + "."
                                                                                                + dataType.getTypeOfList().getColumnDefList().getColumn(j)
                                                                                                .getColumnName().getColumnNameOnly());
                                                                        }
                                                                        else {
                                                                                columnName.setString(resultColumn.getName() + "."
                                                                                                + dataType.getTypeOfList().getColumnDefList().getColumn(j)
                                                                                                                .getColumnName().getColumnNameOnly());
                                                                        }
                                                                        ResultColumn sturctColumn = modelFactory.createResultColumn(resultSet, columnName,
                                                                                        true);
                                                                        sturctColumn.setStruct(true);
                                                                        Function sourceFunction = (Function)createFunction(functionCall);
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(effectType);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(sturctColumn));
                                                                        if (sourceFunction.getColumns() != null && !sourceFunction.getColumns().isEmpty()) {
                                                                                for (ResultColumn column : sourceFunction.getColumns()) {
                                                                                        relation.addSource(new ResultColumnRelationshipElement(column));
                                                                                }
                                                                        }
                                                                }
                                                                resultSet.getColumns().remove(resultColumn);
                                                        }
                                                        return;
                                                }
                                        }
                                }
                        }
                        
                        if(gspObject instanceof TResultColumn) {
                                TResultColumn resultColumn = (TResultColumn)gspObject;
                                if(resultColumn.getAliasClause()!=null && resultColumn.getAliasClause().getColumns()!=null) {
                                        for(TObjectName columnName: resultColumn.getAliasClause().getColumns()) {
                                                analyzeFunctionDataFlowRelation(columnName, Arrays.asList(functionCall), effectType, null);
                                        }
                                        return;
                                }
                        }
                        analyzeFunctionDataFlowRelation(gspObject, Arrays.asList(functionCall), effectType, null);
                }
        }

        private void analyzeFunctionDataFlowRelation(Object gspObject, List<TParseTreeNode> functions,
                        EffectType effectType, Process process) {

                Object modelObject = modelManager.getModel(gspObject);
                if (modelObject == null) {
                        if (gspObject instanceof ResultColumn || gspObject instanceof TableColumn) {
                                modelObject = gspObject;
                        }
                }

                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(effectType);
                relation.setProcess(process);

                if (modelObject instanceof ResultColumn) {
                        relation.setTarget(new ResultColumnRelationshipElement((ResultColumn) modelObject));

                } else if (modelObject instanceof TableColumn) {
                        relation.setTarget(new TableColumnRelationshipElement((TableColumn) modelObject));

                } else {
                        throw new UnsupportedOperationException();
                }

                for (int i = 0; i < functions.size(); i++) {
                        TParseTreeNode functionCall = functions.get(i);

                        if (functionCall instanceof TFunctionCall) {
                                TFunctionCall call = (TFunctionCall) functionCall;
                                Procedure callee = modelManager.getProcedure(callAliasKey(call));
                                if (callee == null && analyzeProcedureDefinition(callAliasKey(call))) {
                                        callee = modelManager.getProcedure(callAliasKey(call));
                                }
                                if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("functionRelation4", call.getFunctionName(), callee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf(call)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.FUNCTION);

                                if (callee != null) {
                                        String procedureParent = getProcedureParentName(stmtStack.peek());
                                        if (procedureParent != null) {
                                                Procedure caller = getEnclosingProcedure(stmtStack.peek());
                                                if (caller != null) {
                                                        CallRelationship callRelation = modelFactory.createCallRelation();
                                                        callRelation.setCallObject(functionCall);
                                                        callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                                        callRelation.addSource(new ProcedureRelationshipElement(callee));
                                                        if (isBuiltInFunctionName(call.getFunctionName()) || isKeyword(call.getFunctionName())) {
                                                                callRelation.setBuiltIn(true);
                                                        }
                                                }
                                        }
                                        if (callee.getArguments() != null) {
                                                for (int j = 0; j < callee.getArguments().size(); j++) {
                                                        Argument argument = callee.getArguments().get(j);
                                                        Variable variable = resolveFormalVariable(callee, argument);
                                                        if(variable!=null) {
                                                                if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                                                        Transform transform = new Transform();
                                                                        transform.setType(Transform.FUNCTION);
                                                                        transform.setCode(call);
                                                                        compositeBindingColumn(variable).setTransform(transform);
                                                                }
                                                                Process callProcess = modelFactory.createProcess(call);
                                                                variable.addProcess(callProcess);
                                                                analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), call, j, callProcess);
                                                        }
                                                }
                                        }
                                        Set<Object> functionTableModelObjs = modelManager.getFunctionResults(nameAliasKey(call.getFunctionName(), null));
                                        if (functionTableModelObjs != null) {
                                                modelManager.bindModel(call, functionTableModelObjs.iterator().next());
                                                for (Object functionTableModelObj : functionTableModelObjs) {
                                                        if (functionTableModelObj instanceof ResultSet) {
                                                                ResultSet resultSet = (ResultSet) functionTableModelObj;
                                                                for (ResultColumn column : resultSet.getColumns()) {
                                                                        relation.addSource(new ResultColumnRelationshipElement(column));
                                                                }
                                                        }
                                                }
                                        }
                                        continue;
                                }
                        }


                        Object functionModel = createFunction(functionCall);
                        if (functionModel instanceof Function) {
                                Function sourceFunction = (Function)functionModel;
                                if (sourceFunction.getColumns() != null && !sourceFunction.getColumns().isEmpty()) {
                                        for (ResultColumn column : sourceFunction.getColumns()) {
                                                relation.addSource(new ResultColumnRelationshipElement(column));
                                        }
                                }
                                else if (functionCall instanceof TFunctionCall) {
                                        relation.addSource(new ResultColumnRelationshipElement((FunctionResultColumn) modelManager
                                                        .getModel(((TFunctionCall) functionCall).getFunctionName())));
                                } else if (functionCall instanceof TCaseExpression) {
                                        relation.addSource(new ResultColumnRelationshipElement((FunctionResultColumn) modelManager
                                                        .getModel(((TCaseExpression) functionCall).getWhenClauseItemList())));
                                }
                                
                                if (sourceFunction != null && !sourceFunction.getRelationRows().getHoldRelations().isEmpty()) {
                                        boolean find = false;
                                        if (modelObject instanceof ResultColumn) {
                                                ResultSetRelationRows targetRelationRows = ((ResultColumn) modelObject).getResultSet().getRelationRows();
                                                if(targetRelationRows.hasRelation()) {
                                                        for(Relationship relationship: targetRelationRows.getHoldRelations()) {
                                                                if(relationship.getSources().contains(sourceFunction.getRelationRows())) {
                                                                        find = true;
                                                                        break;
                                                                }
                                                        }
                                                }
                                        }
                                        else if (modelObject instanceof TableColumn) {
                                                TableRelationRows targetRelationRows = ((TableColumn) modelObject).getTable().getRelationRows();
                                                if(targetRelationRows.hasRelation()) {
                                                        for(Relationship relationship: targetRelationRows.getHoldRelations()) {
                                                                if(relationship.getSources().contains(sourceFunction.getRelationRows())) {
                                                                        find = true;
                                                                        break;
                                                                }
                                                        }
                                                }
                                        }
                                        
                                        if (!find) {
                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                impactRelation.setEffectType(EffectType.select);
                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                sourceFunction.getRelationRows()));
                                                if (modelObject instanceof ResultColumn) {
                                                        impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                        ((ResultColumn) modelObject).getResultSet().getRelationRows()));
                                                } else if (modelObject instanceof TableColumn) {
                                                        impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                        ((TableColumn) modelObject).getTable().getRelationRows()));
                                                }
                                        }
                                }
                        } else if (functionModel instanceof Table) {
                                TFunctionCall call = (TFunctionCall) functionCall;
                                String functionName = call.getFunctionName().toString();
                                boolean flag = false;
                                if (functionName.indexOf(".") != -1) {
                                        String columnName = functionName.substring(functionName.indexOf(".") + 1);
                                        for (TableColumn tableColumn : ((Table) functionModel).getColumns()) {
                                                if (DlineageUtil.sameName(ESQLDataObjectType.dotColumn, DlineageUtil.columnSegmentOf(tableColumn.getName()), columnName)) {
                                                        TableColumnRelationshipElement element = new TableColumnRelationshipElement(tableColumn);
                                                        relation.addSource(element);
                                                        flag = true;
                                                        break;
                                                }
                                        }
                                }

                                if (!flag) {
                                        TableColumn tableColumn = modelFactory.createTableColumn((Table) functionModel,
                                                        ((TFunctionCall) functionCall));
                                        TableColumnRelationshipElement element = new TableColumnRelationshipElement(tableColumn);
                                        relation.addSource(element);
                                }
                        }
                }

        }

        private void analyzeSubqueryDataFlowRelation(Object gspObject, List<TSelectSqlStatement> subquerys,
                        EffectType effectType) {
                analyzeSubqueryDataFlowRelation(gspObject, subquerys, effectType, null);
        }

        private void analyzeSubqueryDataFlowRelation(Object gspObject, List<TSelectSqlStatement> subquerys,
                        EffectType effectType, Process process) {

                Object modelObject = modelManager.getModel(gspObject);
                if (modelObject == null) {
                        if (gspObject instanceof ResultColumn || gspObject instanceof TableColumn) {
                                modelObject = gspObject;
                        }
                }

                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(effectType);
                relation.setProcess(process);

                if (modelObject instanceof ResultColumn) {
                        relation.setTarget(new ResultColumnRelationshipElement((ResultColumn) modelObject));

                } else if (modelObject instanceof TableColumn) {
                        relation.setTarget(new TableColumnRelationshipElement((TableColumn) modelObject));

                } else {
                        throw new UnsupportedOperationException();
                }

                for (int i = 0; i < subquerys.size(); i++) {
                        TSelectSqlStatement subquery = subquerys.get(i);
                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(subquery);
                        if (resultSetModel != null && resultSetModel.getColumns() != null) {
                                for (ResultColumn column : resultSetModel.getColumns()) {
                                        relation.addSource(new ResultColumnRelationshipElement(column));
                                }
                        }
                        
                        if (resultSetModel != null && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                boolean find = false;
                                if (modelObject instanceof ResultColumn) {
                                        ResultSetRelationRows targetRelationRows = ((ResultColumn) modelObject).getResultSet().getRelationRows();
                                        if(targetRelationRows.hasRelation()) {
                                                for(Relationship relationship: targetRelationRows.getHoldRelations()) {
                                                        if(relationship.getSources().contains(resultSetModel.getRelationRows())) {
                                                                find = true;
                                                                break;
                                                        }
                                                }
                                        }
                                }
                                else if (modelObject instanceof TableColumn) {
                                        TableRelationRows targetRelationRows = ((TableColumn) modelObject).getTable().getRelationRows();
                                        if(targetRelationRows.hasRelation()) {
                                                for(Relationship relationship: targetRelationRows.getHoldRelations()) {
                                                        if(relationship.getSources().contains(resultSetModel.getRelationRows())) {
                                                                find = true;
                                                                break;
                                                        }
                                                }
                                        }
                                }
                                
                                if (!find) {
                                        ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.setEffectType(EffectType.select);
                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        resultSetModel.getRelationRows()));
                                        if (modelObject instanceof ResultColumn) {
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                ((ResultColumn) modelObject).getResultSet().getRelationRows()));
                                        } else if (modelObject instanceof TableColumn) {
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                ((TableColumn) modelObject).getTable().getRelationRows()));
                                        }
                                }
                        }
                }

        }

        /**
         * Hive, Spark SQL and Databricks {@code named_struct('a', x, 'b', y)}: a STRUCT whose fields are named by the string
         * literals before their values, as BigQuery {@code STRUCT(x AS a, y AS b)} (Mantis 4847). False in any other
         * dialect, where a function of that name is a routine of the user's, for a qualified name ({@code db.named_struct},
         * a user function too), and for a call whose names are not all non-empty string literals.
         */
        private boolean isNamedStruct(TFunctionCall call) {
                EDbVendor vendor = option.getVendor();
                if (call == null || call.getFunctionName() == null
                                || !gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(vendor).hasNamedStructConstructor()
                                || !gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(vendor).buildsDeclaredTree()
                                || call.getFunctionName().getSchemaToken() != null || call.getFunctionName().getDatabaseToken() != null
                                || call.getArgs() == null || call.getArgs().size() < 2 || call.getArgs().size() % 2 != 0
                                || !"named_struct".equalsIgnoreCase(call.getFunctionName().toString())) { // non-identifier-compare: built-in function name
                        return false;
                }
                for (int i = 0; i < call.getArgs().size(); i += 2) {
                        TExpression name = call.getArgs().getExpression(i);
                        if (name == null || name.getExpressionType() != EExpressionType.simple_constant_t
                                        || name.getConstantOperand() == null
                                        || name.getConstantOperand().getLiteralType() != ELiteralType.etString
                                        || name.getConstantOperand().getValue() == null || name.getConstantOperand().getValue().isEmpty()) {
                                return false;
                        }
                }
                return true;
        }

        /**
         * Plan section 4.4, the constructor registry: the fields of the STRUCT {@code call} builds, each {name, value} in
         * source order, the name null for a field the vendor leaves unnamed; null when {@code call} builds no STRUCT GSP
         * knows. A Hive family {@code named_struct('a', x)} names its fields by the literals, a STRUCT constructor
         * ({@code STRUCT(x AS a)}) by the alias or the column a field reads, and a Hive family {@code struct(x, y)} by the
         * vendor's rule ({@link #positionalStructFieldName}).
         */
        private List<Object[]> constructorFields(TFunctionCall call) {
                if (call == null) {
                        return null;
                }
                List<Object[]> fields = new ArrayList<Object[]>();
                if (isNamedStruct(call)) {
                        for (int i = 0; i + 1 < call.getArgs().size(); i += 2) {
                                fields.add(new Object[]{call.getArgs().getExpression(i).getConstantOperand().getValue(),
                                                call.getArgs().getExpression(i + 1)});
                        }
                        return fields;
                }
                if (call.getFunctionType() == EFunctionType.struct_t && call.getFieldValues() != null) {
                        for (int i = 0; i < call.getFieldValues().size(); i++) {
                                TResultColumn field = call.getFieldValues().getResultColumn(i);
                                String name = null;
                                TObjectName typed = call.getFieldDefs() != null && i < call.getFieldDefs().size()
                                                ? call.getFieldDefs().getColumn(i).getColumnName() : null;
                                if (typed != null) {
                                        // a typed constructor, STRUCT<a STRING>(s.x): the type names the field
                                        name = DlineageUtil.decodeColumnIdentifier(typed.getColumnNameOnly());
                                } else if (field.getAliasClause() != null && field.getAliasClause().getAliasName() != null) {
                                        name = DlineageUtil.decodeAliasIdentifier(field.getAliasClause().getAliasName().toString());
                                } else if (gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(option.getVendor())
                                                .hasNamedStructConstructor()) {
                                        name = positionalStructFieldName(field.getExpr(), i);
                                } else if (field.getFieldAttr() != null && field.getFieldAttr().getFieldPathRead() == null) {
                                        name = DlineageUtil.decodeColumnIdentifier(field.getFieldAttr().getColumnNameOnly());
                                }
                                fields.add(new Object[]{name == null || name.isEmpty() ? null : name, field.getExpr()});
                        }
                        return fields;
                }
                List<String> rowFields = rowCastFieldNames(call);
                if (rowFields != null) {
                        for (int i = 0; i < rowFields.size(); i++) {
                                fields.add(new Object[]{rowFields.get(i), call.getExpr1().getExprList().getExpression(i)});
                        }
                        return fields;
                }
                if (isPositionalStruct(call)) {
                        for (int i = 0; i < call.getArgs().size(); i++) {
                                fields.add(new Object[]{positionalStructFieldName(call.getArgs().getExpression(i), i),
                                                call.getArgs().getExpression(i)});
                        }
                        return fields;
                }
                return null;
        }

        /**
         * Whether {@code call} is the Hive family {@code struct(x, y, ..)} function, unqualified, which builds a STRUCT
         * whose field names the vendor generates ({@link #positionalStructFieldName}). Databricks parses it as a STRUCT
         * constructor with no field list.
         */
        private boolean isPositionalStruct(TFunctionCall call) {
                EDbVendor vendor = option.getVendor();
                return call != null && call.getFunctionName() != null
                                && (call.getFunctionType() != EFunctionType.struct_t || call.getFieldValues() == null)
                                && gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(vendor).hasNamedStructConstructor()
                                && gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(vendor).buildsDeclaredTree()
                                && call.getFunctionName().getSchemaToken() == null && call.getFunctionName().getDatabaseToken() == null
                                && call.getArgs() != null && call.getArgs().size() > 0
                                && "struct".equalsIgnoreCase(call.getFunctionName().toString()); // non-identifier-compare: built-in function name
        }

        /**
         * The name of field {@code index} of a {@link #isPositionalStruct struct(..)}: Hive's GenericUDFStruct names every
         * field {@code col1}, {@code col2}, ..; Spark SQL and Databricks name a field that reads a column after that column
         * (its last field for a field read), and any other field {@code colN} as Hive does.
         */
        private String positionalStructFieldName(TExpression value, int index) {
                EDbVendor vendor = option.getVendor();
                if ((vendor == EDbVendor.dbvsparksql || vendor == EDbVendor.dbvdatabricks) && value != null
                                && value.getExpressionType() == EExpressionType.simple_object_name_t && value.getObjectOperand() != null
                                && !DlineageUtil.isStarName(value.getObjectOperand())) {
                        String name = DlineageUtil.decodeColumnIdentifier(DlineageUtil.fieldLeafText(value.getObjectOperand()));
                        if (name != null && !name.isEmpty()) {
                                return name;
                        }
                }
                return "col" + (index + 1);
        }

        /** Whether a field of the STRUCT {@code call} builds is itself built by a constructor (Mantis 4892). */
        private boolean hasNestedConstructor(TFunctionCall call) {
                List<Object[]> fields = constructorFields(call);
                if (fields == null) {
                        return false;
                }
                for (Object[] field : fields) {
                        TExpression value = (TExpression) field[1];
                        if (value != null && value.getExpressionType() == EExpressionType.function_t
                                        && constructorFields(value.getFunctionCall()) != null) {
                                return true;
                        }
                }
                return false;
        }

        /**
         * The leaves of the STRUCT {@code call} builds, each as {path below the struct, value}, in source order: a field
         * whose value is a constructor contributes its own leaves below its name (Mantis 4892). The recursion follows the
         * nesting of the constructors written, not an expression chain.
         *
         * @return whether every field has a name: an unnamed one has no leaf
         */
        private boolean constructorLeaves(TFunctionCall call, List<String> prefix, List<Object[]> leaves) {
                boolean complete = true;
                for (Object[] field : constructorFields(call)) {
                        TExpression value = (TExpression) field[1];
                        if (field[0] == null || value == null) {
                                complete = false;
                                continue;
                        }
                        List<String> path = new ArrayList<String>(prefix);
                        path.add((String) field[0]);
                        TFunctionCall nested = value.getExpressionType() == EExpressionType.function_t ? value.getFunctionCall() : null;
                        if (nested != null && constructorFields(nested) != null) {
                                complete &= constructorLeaves(nested, path, leaves);
                        } else {
                                leaves.add(new Object[]{path, value});
                        }
                }
                return complete;
        }

        /** The function node of a {@link #isNamedStruct named_struct}: a column per field, fed by its value (Mantis 4847). */
        private Function createNamedStructFunction(TFunctionCall call) {
                Function function = modelFactory.createFunction(call);
                for (int i = 0; i + 1 < call.getArgs().size(); i += 2) {
                        TObjectName field = new TObjectName();
                        field.setString(call.getArgs().getExpression(i).getConstantOperand().getValue());
                        ResultColumn column = modelFactory.createFunctionResultColumn(function, field);
                        columnsInExpr visitor = new columnsInExpr();
                        call.getArgs().getExpression(i + 1).inOrderTraverse(visitor);
                        List<TParseTreeNode> functions = visitor.getFunctions();
                        if (functions != null && !functions.isEmpty()) {
                                analyzeFunctionDataFlowRelation(column, functions, EffectType.function);
                        }
                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                        if (subquerys != null && !subquerys.isEmpty()) {
                                analyzeSubqueryDataFlowRelation(column, subquerys, EffectType.function);
                        }
                        analyzeDataFlowRelation(column, visitor.getObjectNames(), EffectType.function, functions);
                        analyzeConstantDataFlowRelation(column, visitor.getConstants(), EffectType.function, functions);
                }
                return function;
        }

    private Object createFunction(TParseTreeNode functionCall) {
        if (!processingFunctions.add(functionCall)) {
            return modelManager.getModel(functionCall);
        }
        try {

            if (functionCall instanceof TFunctionCall) {
                TFunctionCall functionObj = (TFunctionCall) functionCall;
                // Generic structured-dataflow dispatch. When a vendor adapter (e.g.
                // Spark from_json+explode) returns a descriptor, model the function
                // as a structured generator: per-field result columns linked to
                // exact structured source paths such as nodes[*].key. When no
                // adapter matches, fall through to the existing function logic
                // unchanged.
                StructuredAdapterContext sctx = new StructuredAdapterContext(option.getVendor());
                StructuredDataflowDescriptor sdescriptor =
                        StructuredDataflowRegistry.defaultRegistry().describe(functionObj, sctx);
                if (sdescriptor != null) {
                    Function structuredFn = createStructuredDataflowFunction(sdescriptor);
                    if (structuredFn != null) {
                        return structuredFn;
                    }
                }

                // Oracle basic statements own their call relationship and raw-name binding.
                // Re-entering the legacy lookup here can attach an unresolved/ambiguous
                // call to an unrelated same-named member (and emit it a second time).
                if (!isBuiltInFunctionName(functionObj.getFunctionName())
                        && !isOracleBasicCall(functionObj)) {
                    TCustomSqlStatement stmt = stmtStack.peek();
                    String procedureParent = getProcedureParentName(stmt);
                    if (procedureParent != null) {
                        Procedure procedureCallee = modelManager.getProcedure(callAliasKey(functionObj));
                        if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) shadowCallee("createFunction", functionObj.getFunctionName(), procedureCallee, new Integer[] {gudusoft.gsqlparser.dlineage.routine.RoutineShadow.countAliasOf(functionObj)}, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.FUNCTION);
                        if (procedureCallee != null) {
                            if (procedureParent != null) {
                                Procedure caller = getEnclosingProcedure(stmt);
                                if (caller != null) {
                                    CallRelationship callRelation = modelFactory.createCallRelation();
                                    callRelation.setCallObject(functionCall);
                                    callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                    callRelation.addSource(new ProcedureRelationshipElement(procedureCallee));
                                    if (isBuiltInFunctionName(functionObj.getFunctionName()) || isKeyword(functionObj.getFunctionName())) {
                                        callRelation.setBuiltIn(true);
                                    }
                                }
                            }
                            if (procedureCallee.getArguments() != null) {
                                for (int j = 0; j < procedureCallee.getArguments().size(); j++) {
                                    Argument argument = procedureCallee.getArguments().get(j);
                                    Variable variable = modelFactory.createVariable(procedureCallee, argument.getName(), false);
                                    if (variable != null) {
                                        if (argument.getMode() == EParameterMode.out || argument.getMode() == EParameterMode.output) {
                                            Transform transform = new Transform();
                                            transform.setType(Transform.FUNCTION);
                                            transform.setCode(functionObj);
                                            compositeBindingColumn(variable).setTransform(transform);
                                        }
                                        Process process = modelFactory.createProcess(functionObj);
                                        variable.addProcess(process);
                                        analyzeFunctionArgumentsDataFlowRelation(compositeBindingColumn(variable), functionObj, j, process);
                                    }
                                }
                            }
                        } else {
                            TFunctionCall call = (TFunctionCall) functionCall;
                            String functionName = call.getFunctionName().toString();
                            List<String> functionNameParts = SQLUtil.parseNames(functionName, getOption().getVendor());
                            if (functionNameParts.size() == 2) {
                                // The record a rec.method() call names; else an object of that name. The name is
                                // split as a qualified name, so a delimited part may contain a dot.
                                String qualifier = functionNameParts.get(0);
                                Table functionTable = modelManager.visibleLocal(qualifier, LocalSymbolKey.Kind.VARIABLE);
                                if (functionTable == null) {
                                    functionTable = modelManager.getTableByName(DlineageUtil.getTableIdentityKey(qualifier));
                                }
                                if (functionTable != null) {
                                    String columnName = functionNameParts.get(1);
                                    for (TableColumn tableColumn : functionTable.getColumns()) {
                                        if (DlineageUtil.sameName(ESQLDataObjectType.dotColumn, DlineageUtil.columnSegmentOf(tableColumn.getName()), columnName)) {
                                            return functionTable;
                                        }
                                    }
                                }
                            }
                            Function function = modelFactory.createFunction(call);
                            if (procedureParent != null) {
                                Procedure caller = getEnclosingProcedure(stmt);
                                if (caller != null) {
                                    CallRelationship callRelation = modelFactory.createCallRelation();
                                    callRelation.setCallObject(functionCall);
                                    callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                    callRelation.addSource(new FunctionRelationshipElement(function));
                                    if (isBuiltInFunctionName(functionObj.getFunctionName()) || isKeyword(functionObj.getFunctionName())) {
                                        callRelation.setBuiltIn(true);
                                    }
                                }
                            }
                        }
                    }
                } else if (isConstantFunction(functionObj.getFunctionName())
                        && (functionObj.getArgs() == null || functionObj.getArgs().size() == 0)) {
                    if (option.isShowConstantTable()) {
                        Table constantTable = modelFactory.createConstantsTable(stmtStack.peek());
                        modelFactory.createTableColumn(constantTable, functionObj);
                        return constantTable;
                    } else {
                        return null;
                    }
                }

                if (functionObj.getFunctionType() == EFunctionType.struct_t) {
                    Function function = modelFactory.createFunction((TFunctionCall) functionCall);
                    if (functionObj instanceof TTableFunction) {
                        TTableFunction tableFunction = (TTableFunction) functionObj;
                        if (tableFunction.getFieldValues() != null) {
                            for (int i = 0; i < tableFunction.getFieldValues().size(); i++) {
                                TResultColumn resultColumn = tableFunction.getFieldValues().getResultColumn(i);
                                // a typed constructor, STRUCT<a STRING>(s.x), names its field by the type (owner
                                // ruling 2026-10-07)
                                TObjectName typedField = tableFunction.getFieldDefs() != null
                                        && i < tableFunction.getFieldDefs().size()
                                        ? tableFunction.getFieldDefs().getColumn(i).getColumnName() : null;
                                if (typedField != null || resultColumn.getAliasClause() != null) {
                                    ResultColumn column = modelFactory.createFunctionResultColumn(function,
                                            typedField != null ? typedField : resultColumn.getAliasClause().getAliasName());
                                    columnsInExpr visitor = new columnsInExpr();
                                    resultColumn.getExpr().inOrderTraverse(visitor);
                                    List<TObjectName> objectNames = visitor.getObjectNames();
                                    List<TParseTreeNode> functions = visitor.getFunctions();
                                    if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(column, functions, EffectType.function);
                                    }
                                    List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                    if (subquerys != null && !subquerys.isEmpty()) {
                                        analyzeSubqueryDataFlowRelation(column, subquerys, EffectType.function);
                                    }
                                    analyzeDataFlowRelation(column, objectNames, EffectType.function, functions);
                                    List<TParseTreeNode> constants = visitor.getConstants();
                                    analyzeConstantDataFlowRelation(column, constants, EffectType.function, functions);
                                } else if (resultColumn.getFieldAttr() != null) {
                                    ResultColumn column = modelFactory.createFunctionResultColumn(function,
                                            resultColumn.getFieldAttr());
                                    analyzeDataFlowRelation(column, Arrays.asList(resultColumn.getFieldAttr()), EffectType.function, null);
                                } else if (resultColumn.getExpr() != null) {
                                    if (resultColumn.getExpr().getFunctionCall() != null) {
                                        Function resultColumnFunction = (Function) createFunction(
                                                resultColumn.getExpr().getFunctionCall());
                                        String functionName = getResultSetName(function);
                                        for (int j = 0; j < resultColumnFunction.getColumns().size(); j++) {
                                            TObjectName columnName = new TObjectName();
                                            if (resultColumn.getAliasClause() != null) {
                                                columnName.setString(resultColumn.getAliasClause() + "." + getColumnNameOnly(
                                                        resultColumnFunction.getColumns().get(j).getName()));
                                            } else {
                                                columnName.setString(functionName + "." + getColumnNameOnly(
                                                        resultColumnFunction.getColumns().get(j).getName()));
                                            }
                                            ResultColumn functionResultColumn = modelFactory.createResultColumn(function,
                                                    columnName);
                                            DataFlowRelationship relationship = modelFactory.createDataFlowRelation();
                                            relationship.setTarget(new ResultColumnRelationshipElement(functionResultColumn));
                                            relationship.addSource(new ResultColumnRelationshipElement(
                                                    resultColumnFunction.getColumns().get(j)));
                                        }
                                    } else if (resultColumn.getExpr().getCaseExpression() != null) {
                                        function = modelFactory.createFunction(resultColumn.getExpr().getCaseExpression());
                                        ResultColumn column = modelFactory.createFunctionResultColumn(function,
                                                ((TCaseExpression) resultColumn.getExpr().getCaseExpression()).getWhenClauseItemList());
                                        analyzeFunctionArgumentsDataFlowRelation(column, functionCall);
                                    }
                                }
                            }
                            return function;
                        }
                    } else if (functionObj instanceof TFunctionCall) {

                    }
                }

                // BigQuery array_agg(table_alias) row-reference expansion
                if (functionObj.getFunctionType() == EFunctionType.array_agg_t
                        && option.getVendor() == EDbVendor.dbvbigquery
                        && functionObj.getArgs() != null
                        && functionObj.getArgs().size() == 1) {

                    TExpression arg0 = functionObj.getArgs().getExpression(0);
                    if (arg0 != null
                            && arg0.getExpressionType() == EExpressionType.simple_object_name_t) {

                        TObjectName on = arg0.getObjectOperand();
                        if (isArrayAggRowReference(on)) {
                            Function function = (Function) modelManager.getModel(functionCall);
                            if (function == null) {
                                function = modelFactory.createFunction((TFunctionCall) functionCall);
                            }

                            // Only bind once (avoid duplicate processing when
                            // createFunction is called from analyzeFunctionDataFlowRelation)
                            if (function.getColumns() == null || function.getColumns().isEmpty()) {
                                TTable srcTable = on.getSourceTable();
                                String tableAlias = srcTable.getAliasName() != null
                                        ? srcTable.getAliasName().toString() : null;

                                Table sourceTable = (Table) modelManager.getModel(srcTable);
                                sourceTable.removeColumn(tableAlias);

                                // Collect inferred column names from ORDER BY (in function)
                                // and GROUP BY (in enclosing SELECT). Excludes the table alias.
                                List<TObjectName> inferredColumns = collectRowReferenceInferredColumns(
                                        functionObj, tableAlias);

                                // Create a single * function result column carrying star-link
                                // metadata for the inferred columns and direct source edges
                                // for * and each inferred column.
                                createRowReferenceStarColumn(function, srcTable, inferredColumns);
                            }

                            return function;
                        }
                    }
                }

                if (functionObj.getFunctionType() == EFunctionType.array_t || functionObj.getFunctionType() == EFunctionType.array_agg_t) {
                    Function function = modelFactory.createFunction((TFunctionCall) functionCall);
                    if (functionObj.getArgs() != null) {
                        if (functionObj.getArgs().getExpression(0).getSubQuery() != null) {
                            TSelectSqlStatement stmt = functionObj.getArgs().getExpression(0).getSubQuery();
                            analyzeSelectStmt(stmt);
                            ResultSet resultset = (ResultSet) modelManager.getModel(stmt);
                            for (int i = 0; i < resultset.getColumns().size(); i++) {
                                ResultColumn sourceColumn = resultset.getColumns().get(i);
                                TObjectName columnName = new TObjectName();
                                columnName.setString(sourceColumn.getName());
                                ResultColumn resultColumn = modelFactory.createFunctionResultColumn(function,
                                        columnName);
                                DataFlowRelationship relationship = modelFactory.createDataFlowRelation();
                                relationship.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                relationship.addSource(
                                        new ResultColumnRelationshipElement(sourceColumn));
                            }
                            return function;
                        } else if (functionObj.getArgs().getExpression(0).getExpressionType() == EExpressionType.function_t) {
                            Object functionTableModelObj = createFunction(functionObj.getArgs().getExpression(0).getFunctionCall());
                            if (functionTableModelObj instanceof ResultSet) {
                                ResultSet resultset = (ResultSet) functionTableModelObj;
                                for (int i = 0; i < resultset.getColumns().size(); i++) {
                                    ResultColumn sourceColumn = resultset.getColumns().get(i);
                                    TObjectName columnName = new TObjectName();
                                    columnName.setString(sourceColumn.getName());
                                    ResultColumn resultColumn = modelFactory.createFunctionResultColumn(function, columnName);
                                    DataFlowRelationship relationship = modelFactory.createDataFlowRelation();
                                    relationship.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                    relationship.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                }
                                return function;
                            }
                        }
                    }
                }

                Function function = modelFactory.createFunction((TFunctionCall) functionCall);
                ResultColumn column = modelFactory.createFunctionResultColumn(function,
                        ((TFunctionCall) functionCall).getFunctionName());
                if ("COUNT".equalsIgnoreCase(builtInFunctionName((TFunctionCall) functionCall))) { // non-identifier-compare: built-in function name
                    // @see https://e.gitee.com/gudusoft/issues/list?issue=I40NUP
                    // COUNT特殊处理，不和参数关联
                    if (option.isShowCountTableColumn()) {
                        analyzeFunctionArgumentsDataFlowRelation(column, functionCall);
                    }
                } else {
                    boolean isCustomFunction = !isOracleBasicCall((TFunctionCall) functionCall)
                            && analyzeCustomFunctionCall((TFunctionCall) functionCall);
//                              if(!isCustomFunction) 
                    {
                        analyzeFunctionArgumentsDataFlowRelation(column, functionCall);
                    }
                    Set<Object> functionTableModelObjs = modelManager.getFunctionResults(functionAliasKey(function));
                    if (functionTableModelObjs != null) {
                        for (Object functionTableModelObj : functionTableModelObjs) {
                            if (functionTableModelObj instanceof ResultSet) {
                                ResultSet functionTableModel = (ResultSet) functionTableModelObj;
                                if (functionTableModel.getColumns() != null) {
                                    for (int j = 0; j < functionTableModel.getColumns().size(); j++) {
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(EffectType.select);
                                        relation.setTarget(new ResultColumnRelationshipElement(column));
                                        relation.addSource(new ResultColumnRelationshipElement(
                                                functionTableModel.getColumns().get(j)));
                                    }
                                }
                            }
                        }
                    }
                }
                return function;
            } else if (functionCall instanceof TCaseExpression) {
                Function function = modelFactory.createFunction((TCaseExpression) functionCall);
                ResultColumn column = modelFactory.createFunctionResultColumn(function,
                        ((TCaseExpression) functionCall).getWhenClauseItemList());
                analyzeFunctionArgumentsDataFlowRelation(column, functionCall);
                return function;
            } else if (functionCall instanceof TObjectName) {
                Function function = modelFactory.createFunction((TObjectName) functionCall);
                TObjectName columnName = new TObjectName();
                columnName.setString(function.getFunctionName());
                ResultColumn column = modelFactory.createResultColumn(function,
                        columnName);
                analyzeFunctionArgumentsDataFlowRelation(column, functionCall);
                return function;
            }
            return null;
        } finally {
            processingFunctions.remove(functionCall);
        }
    }

        /**
         * The legacy normal-name text of a function model's name.
         *
         * @deprecated function results are looked up by the function's name as written; nothing here calls this any more,
         *             and it stays for subclasses
         */
        @Deprecated
        protected String getIdentifiedFunctionName(Function function) {
                return LegacyDlineageWireNamesV1.functionName(function.getFunctionName());
        }
        
        private boolean isConstantFunction(TObjectName functionName) {
                boolean result = CONSTANT_BUILTIN_FUNCTIONS.contains(functionName.toString().toUpperCase(Locale.ROOT));
                if (result) {
                        return true;
                }
                return false;
        }

        private void analyzeFunctionArgumentsDataFlowRelation(Object resultColumn, TParseTreeNode gspObject) {
                List<TExpression> directExpressions = new ArrayList<TExpression>();
                List<TExpression> indirectExpressions = new ArrayList<TExpression>();
                List<TExpression> conditionExpressions = new ArrayList<TExpression>();
                if (gspObject instanceof TFunctionCall) {
                        TFunctionCall functionCall = (TFunctionCall) gspObject;
                        getFunctionExpressions(directExpressions, indirectExpressions, functionCall);
                } else if (gspObject instanceof TCaseExpression) {
                        TCaseExpression expr = (TCaseExpression) gspObject;
                        TExpression inputExpr = expr.getInput_expr();
                        if (inputExpr != null) {
                                if(option.isShowCaseWhenAsDirect()){
                                        directExpressions.add(inputExpr);
                                }
                                else {
                                        conditionExpressions.add(inputExpr);
                                }
                        }
                        TExpression defaultExpr = expr.getElse_expr();
                        if (defaultExpr != null) {
                                directExpressions.add(defaultExpr);
                        }
                        TWhenClauseItemList list = expr.getWhenClauseItemList();
                        for (int i = 0; i < list.size(); i++) {
                                TWhenClauseItem element = list.getWhenClauseItem(i);
                                if(option.isShowCaseWhenAsDirect()){
                                        directExpressions.add(element.getComparison_expr());
                                }
                                else {
                                        conditionExpressions.add(element.getComparison_expr());
                                }
                                directExpressions.add(element.getReturn_expr());
                        }
                }

                for (int j = 0; j < directExpressions.size(); j++) {
                        columnsInExpr visitor = new columnsInExpr();
                        directExpressions.get(j).inOrderTraverse(visitor);

                        List<TObjectName> objectNames = visitor.getObjectNames();
                        List<TParseTreeNode> functions = visitor.getFunctions();

                        if (functions != null && !functions.isEmpty()) {
                                analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                        }

                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                        if (subquerys != null && !subquerys.isEmpty()) {
                                analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.function);
                        }

                        analyzeDataFlowRelation(resultColumn, objectNames, EffectType.function, functions);

                        List<TParseTreeNode> constants = visitor.getConstants();
                        analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.function, functions);
                }

                conditionExpressions.addAll(indirectExpressions);
                for (int j = 0; j < conditionExpressions.size(); j++) {
                        analyzeFilterCondition(resultColumn, conditionExpressions.get(j), null, null, EffectType.function);
                }
        }
        
        private void analyzeFunctionArgumentsDataFlowRelation(Object resultColumn, TCallStatement callStatment, int argumentIndex, Process process) {
                List<TExpression> directExpressions = new ArrayList<TExpression>();
                List<TExpression> indirectExpressions = new ArrayList<TExpression>();
                List<TExpression> conditionExpressions = new ArrayList<TExpression>();

                getFunctionExpressions(directExpressions, indirectExpressions, callStatment, argumentIndex);

                for (int j = 0; j < directExpressions.size(); j++) {
                        columnsInExpr visitor = new columnsInExpr();
                        directExpressions.get(j).inOrderTraverse(visitor);

                        List<TObjectName> objectNames = visitor.getObjectNames();
                        List<TParseTreeNode> functions = visitor.getFunctions();

                        if (functions != null && !functions.isEmpty()) {
                                analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                        }

                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                        if (subquerys != null && !subquerys.isEmpty()) {
                                analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.function);
                        }

                        DataFlowRelationship relation = analyzeDataFlowRelation(resultColumn, objectNames, EffectType.function, functions);
                        if (relation != null) {
                                relation.setProcess(process);
                        }

                        List<TParseTreeNode> constants = visitor.getConstants();
                        analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.function, functions);
                }

                conditionExpressions.addAll(indirectExpressions);
                for (int j = 0; j < conditionExpressions.size(); j++) {
                        analyzeFilterCondition(resultColumn, conditionExpressions.get(j), null, null, EffectType.function);
                }
        }

        private void analyzeFunctionArgumentsDataFlowRelation(Object resultColumn, TDb2CallStmt callStatment, int argumentIndex, Process process) {
                List<TExpression> directExpressions = new ArrayList<TExpression>();
                List<TExpression> indirectExpressions = new ArrayList<TExpression>();
                List<TExpression> conditionExpressions = new ArrayList<TExpression>();

                getFunctionExpressions(directExpressions, indirectExpressions, callStatment, argumentIndex);

                for (int j = 0; j < directExpressions.size(); j++) {
                        columnsInExpr visitor = new columnsInExpr();
                        directExpressions.get(j).inOrderTraverse(visitor);

                        List<TObjectName> objectNames = visitor.getObjectNames();
                        List<TParseTreeNode> functions = visitor.getFunctions();

                        if (functions != null && !functions.isEmpty()) {
                                analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                        }

                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                        if (subquerys != null && !subquerys.isEmpty()) {
                                analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.function);
                        }

                        DataFlowRelationship relation = analyzeDataFlowRelation(resultColumn, objectNames, EffectType.function, functions);
                        if (relation != null) {
                                relation.setProcess(process);
                        }

                        List<TParseTreeNode> constants = visitor.getConstants();
                        analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.function, functions);
                }

                conditionExpressions.addAll(indirectExpressions);
                for (int j = 0; j < conditionExpressions.size(); j++) {
                        analyzeFilterCondition(resultColumn, conditionExpressions.get(j), null, null, EffectType.function);
                }
        }

        private void analyzeFunctionArgumentsDataFlowRelation(Object resultColumn, TFunctionCall functionCall, int argumentIndex, Process process) {
                List<TExpression> directExpressions = new ArrayList<TExpression>();
                List<TExpression> indirectExpressions = new ArrayList<TExpression>();
                List<TExpression> conditionExpressions = new ArrayList<TExpression>();

                getFunctionExpressions(directExpressions, indirectExpressions, functionCall, argumentIndex);

                for (int j = 0; j < directExpressions.size(); j++) {
                        columnsInExpr visitor = new columnsInExpr();
                        TExpression argument = directExpressions.get(j);
                        if (option.getVendor() == EDbVendor.dbvoracle
                                        && argument.getExpressionType() == EExpressionType.ref_arrow_t) {
                                // In formal => value, the left name labels a parameter; only value flows.
                                argument = argument.getRightOperand();
                        }
                        if (argument == null) continue;
                        argument.inOrderTraverse(visitor);

                        List<TObjectName> objectNames = visitor.getObjectNames();
                        List<TParseTreeNode> functions = visitor.getFunctions();

                        if (functions != null && !functions.isEmpty()) {
                                analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                        }

                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                        if (subquerys != null && !subquerys.isEmpty()) {
                                analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.function);
                        }

                        DataFlowRelationship relation = analyzeDataFlowRelation(resultColumn, objectNames, EffectType.function, functions);
                        if (relation != null) {
                                relation.setProcess(process);
                        }

                        List<TParseTreeNode> constants = visitor.getConstants();
                        analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.function, functions);
                }

                conditionExpressions.addAll(indirectExpressions);
                for (int j = 0; j < conditionExpressions.size(); j++) {
                        analyzeFilterCondition(resultColumn, conditionExpressions.get(j), null, null, EffectType.function);
                }
        }

        private void analyzeFunctionArgumentsDataFlowRelation(Object resultColumn, TMssqlExecute functionCall, String argumentName, int argumentIndex, Process process) {
                List<TExpression> directExpressions = new ArrayList<TExpression>();
                List<TExpression> indirectExpressions = new ArrayList<TExpression>();
                List<TExpression> conditionExpressions = new ArrayList<TExpression>();

                getFunctionExpressions(directExpressions, indirectExpressions, functionCall, argumentName, argumentIndex);

                for (int j = 0; j < directExpressions.size(); j++) {
                        columnsInExpr visitor = new columnsInExpr();
                        directExpressions.get(j).inOrderTraverse(visitor);

                        List<TObjectName> objectNames = visitor.getObjectNames();
                        List<TParseTreeNode> functions = visitor.getFunctions();

                        if (functions != null && !functions.isEmpty()) {
                                analyzeFunctionDataFlowRelation(resultColumn, functions, EffectType.function);
                        }

                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                        if (subquerys != null && !subquerys.isEmpty()) {
                                analyzeSubqueryDataFlowRelation(resultColumn, subquerys, EffectType.function);
                        }

                        DataFlowRelationship relation = analyzeDataFlowRelation(resultColumn, objectNames, EffectType.function, functions);
                        if (relation != null) {
                                relation.setProcess(process);
                        }

                        List<TParseTreeNode> constants = visitor.getConstants();
                        analyzeConstantDataFlowRelation(resultColumn, constants, EffectType.function, functions);
                }

                conditionExpressions.addAll(indirectExpressions);
                for (int j = 0; j < conditionExpressions.size(); j++) {
                        analyzeFilterCondition(resultColumn, conditionExpressions.get(j), null, null, EffectType.function);
                }
        }


        private static void addResultColumnListExpressions(
                        TResultColumnList list, List<TExpression> target) {
                if (list == null) return;
                for (int k = 0; k < list.size(); k++) {
                        TExpression e = list.getResultColumn(k).getExpr();
                        if (e != null) target.add(e);
                }
        }

        private static void addPassingClauseExpressions(
                        TFunctionCall fc, List<TExpression> target) {
                TResultColumnList list = null;
                if (fc.getXmlPassingClause() != null
                                && fc.getXmlPassingClause().getPassingList() != null) {
                        list = fc.getXmlPassingClause().getPassingList();
                } else if (fc.getPassingClause() != null
                                && fc.getPassingClause().getPassingList() != null) {
                        list = fc.getPassingClause().getPassingList();
                }
                addResultColumnListExpressions(list, target);
        }

        private void collectOracleXmlFunctionExpressions(
                        TFunctionCall fc,
                        List<TExpression> direct,
                        List<TExpression> indirect) {

                if (option.getVendor() != EDbVendor.dbvoracle) return;

                // XMLELEMENT: value exprs + XMLATTRIBUTES exprs (direct)
                addResultColumnListExpressions(fc.getXMLElementValueExprList(), direct);
                if (fc.getXMLAttributesClause() != null) {
                        addResultColumnListExpressions(
                                        fc.getXMLAttributesClause().getValueExprList(), direct);
                }

                // XMLFOREST (direct)
                addResultColumnListExpressions(fc.getXMLForestValueList(), direct);

                // EXTRACT(XML) — AST-shape disambiguation (V3)
                // XML form populates getXMLType_Instance(); scalar EXTRACT(YEAR FROM d) does not.
                if (fc.getXMLType_Instance() != null) {
                        direct.add(fc.getXMLType_Instance());
                }

                String name = fc.getFunctionName() == null
                                ? "" : fc.getFunctionName().toString().toUpperCase(Locale.ROOT);

                // XMLEXISTS indirect (filter) from PASSING expressions
                if ("XMLEXISTS".equals(name)) {
                        addPassingClauseExpressions(fc, indirect);
                }

                // XMLAGG / SYS_XMLAGG ORDER BY → indirect
                if (("XMLAGG".equals(name) || "SYS_XMLAGG".equals(name))
                                && fc.getSortClause() != null) {
                        TOrderByItemList orderByList = fc.getSortClause().getItems();
                        if (orderByList != null) {
                                for (int k = 0; k < orderByList.size(); k++) {
                                        TExpression e = orderByList.getOrderByItem(k).getSortKey();
                                        if (e != null) indirect.add(e);
                                }
                        }
                }

                // DELIBERATELY NOT HARVESTED (metadata, not data):
                //   fc.getTypeExpression()       — target type for XMLCAST
                //   fc.getXMLElementNameExpr()   — element tag identifier
                //   XPath / XQuery literal strings that appear as function args
                //   datatype / format / style tokens
        }

        private void collectArrayAggOrderByExpressions(
                        TFunctionCall fc,
                        List<TExpression> direct,
                        List<TExpression> indirect) {
                if (fc.getFunctionType() != EFunctionType.array_agg_t) return;

                TOrderByItemList items = null;
                if (fc.getSortClause() != null) items = fc.getSortClause().getItems();
                if (items == null || items.size() == 0) {
                        items = fc.getOrderByList();
                }
                if (items == null) return;

                // Resolve source tables for ORDER BY columns that the parser
                // doesn't link (they're inside a function call, outside the
                // resolver's normal scope)
                TTable fallbackTable = null;
                if (!stmtStack.isEmpty() && stmtStack.peek() instanceof TSelectSqlStatement) {
                        TTableList tables = ((TSelectSqlStatement) stmtStack.peek()).tables;
                        if (tables != null && tables.size() > 0) {
                                fallbackTable = tables.getTable(0);
                        }
                }

                for (int k = 0; k < items.size(); k++) {
                        TExpression e = items.getOrderByItem(k).getSortKey();
                        if (e != null) {
                                if (fallbackTable != null
                                                && e.getExpressionType() == EExpressionType.simple_object_name_t
                                                && e.getObjectOperand() != null
                                                && e.getObjectOperand().getSourceTable() == null) {
                                        SqllrObservations decided = SqllrObservations.current();
                                        if (decided != null) {
                                                // recorded before the write-back below changes the name (plan 06, Section 3.3, #3)
                                                decided.decision(SqllrObservations.DECISION_ARRAY_AGG_ORDER_BY_FIRST_TABLE, e.getObjectOperand(),
                                                                fallbackTable, "an ARRAY_AGG ORDER BY key no resolver linked");
                                        }
                                        e.getObjectOperand().setSourceTable(fallbackTable);
                                }
                                direct.add(e);
                        }
                }
        }

        /**
         * ORDER BY inside the argument list of an aggregate, as in LIST(x, ',' ORDER BY y) or
         * string_agg(x, ',' ORDER BY y). The keys decide the order of the values in the result, so each is
         * an indirect source of the function, like an OVER (ORDER BY ...) or WITHIN GROUP key. The two
         * collectors above have already taken the keys of Oracle XMLAGG (indirect) and BigQuery ARRAY_AGG
         * (direct); a key already collected is not added twice.
         */
        private void collectAggregateOrderByExpressions(
                        TFunctionCall fc,
                        List<TExpression> direct,
                        List<TExpression> indirect) {
                if (fc.getSortClause() == null) return;
                TOrderByItemList items = fc.getSortClause().getItems();
                for (int k = 0; k < items.size(); k++) {
                        TExpression e = items.getOrderByItem(k).getSortKey();
                        if (e != null && !containsNode(direct, e) && !containsNode(indirect, e)) {
                                indirect.add(e);
                        }
                }
        }

        private static boolean containsNode(List<TExpression> list, TExpression e) {
                for (TExpression item : list) {
                        if (item == e) return true;
                }
                return false;
        }

        private boolean isArrayAggRowReference(TObjectName on) {
                if (on == null) return false;
                TTable src = on.getSourceTable();
                if (src == null) return false;

                // Raw equivalent of the old getColumnName extraction (toString fallback preserved).
                String raw = on.getColumnNameOnly();
                if (raw == null || raw.trim().isEmpty()) {
                        raw = on.toString() == null ? "" : on.toString().trim();
                } else {
                        raw = raw.trim();
                }
                if (raw.isEmpty()) return false;

                // Check if identifier text matches the table alias or table name (canonical dotTable).
                boolean matchesAlias =
                        (src.getAliasName() != null
                                && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotTable, raw, src.getAliasName().toString()))
                        || (src.getTableName() != null
                                && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotTable, raw, src.getTableName().toString()));
                return matchesAlias;
        }

        /**
         * Collects column names inferred from a row-reference array_agg:
         *  - ORDER BY keys inside the function call
         *  - GROUP BY keys in the enclosing SELECT
         * Excludes the table alias itself (so `original` in `array_agg(original)`
         * does not leak into the column list).
         */
        private List<TObjectName> collectRowReferenceInferredColumns(
                        TFunctionCall functionCall, String tableAlias) {
                List<TObjectName> columns = new ArrayList<TObjectName>();

                TOrderByItemList orderItems = null;
                if (functionCall.getSortClause() != null) {
                        orderItems = functionCall.getSortClause().getItems();
                }
                if (orderItems == null || orderItems.size() == 0) {
                        orderItems = functionCall.getOrderByList();
                }
                if (orderItems != null) {
                        for (int k = 0; k < orderItems.size(); k++) {
                                TExpression sortKey = orderItems.getOrderByItem(k).getSortKey();
                                collectInferredColumn(sortKey, tableAlias, columns);
                        }
                }

                if (!stmtStack.isEmpty() && stmtStack.peek() instanceof TSelectSqlStatement) {
                        TSelectSqlStatement select = (TSelectSqlStatement) stmtStack.peek();
                        if (select.getGroupByClause() != null) {
                                TGroupByItemList groupByList = select.getGroupByClause().getItems();
                                for (int k = 0; k < groupByList.size(); k++) {
                                        TExpression expr = groupByList.getGroupByItem(k).getExpr();
                                        collectInferredColumn(expr, tableAlias, columns);
                                }
                        }
                }
                return columns;
        }

        private void collectInferredColumn(TExpression expr, String tableAlias,
                        List<TObjectName> columns) {
                if (expr == null) return;
                if (expr.getExpressionType() != EExpressionType.simple_object_name_t) return;
                if (expr.getObjectOperand() == null) return;
                String colName = expr.getObjectOperand().getColumnNameOnly();
                if (colName == null || colName.trim().isEmpty()) colName = expr.getObjectOperand().toString();
                if (colName == null || colName.isEmpty()) return;
                if (tableAlias != null && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotTable, tableAlias, colName)) return;
                if(!columns.contains(expr.getObjectOperand())) {
                        columns.add(expr.getObjectOperand());
                }
        }

        /**
         * Creates a `*` FunctionResultColumn plus one FunctionResultColumn per
         * inferred column. Each column gets its own source-edge back to
         * the source table (source.* -> function.*, source.id -> function.id, etc).
         *
         * Downstream, the `*` column collects all three edges into the inner
         * `unique` ResultColumn, and post-processing (rewriteArrayAggRowReferenceTargets)
         * splits the collapsed CTAS relation into one per column.
         */
        private void createRowReferenceStarColumn(Function function, TTable src,
                        List<TObjectName> inferredColumns) {
                Object tableModel = modelManager.getModel(src);

                // Create function.* and bind source.* -> function.*
                TObjectName starName = DlineageUtil.syntheticStarName();
                ResultColumn starColumn = modelFactory.createFunctionResultColumn(function, starName);
                starColumn.setStruct(true);
                starColumn.setShowStar(true);

                if (tableModel instanceof Table) {
                        Table sourceTable = (Table) tableModel;
                        TableColumn sourceCol = findOrCreateTableStarColumn(sourceTable);
                        
                        for (TObjectName colName : inferredColumns) {
                                TableColumn tableColumn = modelFactory.createTableColumn(sourceTable, colName, false);
                                if (tableColumn != null) {
                                        //order by and group by fdr relation
                                        AbstractRelationship relation = modelFactory.createImpactRelation();
                                        relation.setEffectType(EffectType.function);
                                        relation.setTarget(new ResultColumnRelationshipElement(starColumn));
                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                        
                                        // star column fdd relation
                                        relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(EffectType.function);
                                        relation.setTarget(new ResultColumnRelationshipElement(starColumn));
                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                }
                        }

                        
                        if (sourceCol != null) {
                                DataFlowRelationship rel = modelFactory.createDataFlowRelation();
                                rel.setEffectType(EffectType.function);
                                rel.setTarget(new ResultColumnRelationshipElement(starColumn));
                                rel.addSource(new TableColumnRelationshipElement(sourceCol));
                        }
                        
                } else if (tableModel instanceof ResultSet) {
                        ResultSet sourceRS = (ResultSet) tableModel;
                        ResultColumn sourceCol = findOrCreateResultStarColumn(sourceRS);
                        for (TObjectName colName : inferredColumns) {
                                sourceCol.bindStarLinkColumn(colName);
                        }
                        
                        if (sourceCol != null) {
                                DataFlowRelationship rel = modelFactory.createDataFlowRelation();
                                rel.setEffectType(EffectType.function);
                                rel.setTarget(new ResultColumnRelationshipElement(starColumn));
                                rel.addSource(new ResultColumnRelationshipElement(sourceCol));
                        }
                }
        }

        /**
         * Builds the Function lineage model for a structured-dataflow descriptor.
         * Creates per-field FunctionResultColumns and links each to an exact
         * structured source TableColumn (e.g. {@code nodes[*].key}). Returns the
         * Function on success; returns {@code null} when the source column cannot
         * be resolved so the caller falls back to existing function lineage.
         */
        private Function createStructuredDataflowFunction(StructuredDataflowDescriptor desc) {
                TParseTreeNode syntaxNode = desc.getSyntaxNode();
                if (!(syntaxNode instanceof TFunctionCall)) {
                        return null;
                }
                TFunctionCall fnCall = (TFunctionCall) syntaxNode;

                Function function = null;
                Object existing = modelManager.getModel(fnCall);
                if (existing instanceof Function) {
                        function = (Function) existing;
                }
                boolean alreadyBuilt = function != null
                                && function.getColumns() != null
                                && !function.getColumns().isEmpty();
                if (alreadyBuilt) {
                        return function;
                }
                if (function == null) {
                        function = modelFactory.createFunction(fnCall);
                }

                StructuredValueSource src = desc.getSource();
                TObjectName sourceColumn = src.getSourceColumn();
                TTable srcTable = sourceColumn != null ? sourceColumn.getSourceTable() : null;
                Object srcTableModel = srcTable != null ? modelManager.getModel(srcTable) : null;
                if (!(srcTableModel instanceof Table)) {
                        return null;
                }
                Table sourceTable = (Table) srcTableModel;

                for (StructuredFieldBinding fb : desc.getFieldBindings()) {
                        TableColumn pathColumn = findOrCreateStructuredPathColumn(sourceTable, fb.getSourcePath());
                        if (pathColumn == null) {
                                continue;
                        }

                        TObjectName fieldName = new TObjectName();
                        fieldName.setString(fb.getOutputFieldName());
                        ResultColumn fnResult = modelFactory.createFunctionResultColumn(function, fieldName);

                        DataFlowRelationship rel = modelFactory.createDataFlowRelation();
                        rel.setEffectType(EffectType.function);
                        rel.setTarget(new ResultColumnRelationshipElement(fnResult));
                        rel.addSource(new TableColumnRelationshipElement(pathColumn));
                }
                return function;
        }

        /**
         * Resolve a struct-field-style outer reference ({@code structAlias.field}
         * or {@code relAlias.structAlias.field}) against in-scope subquery
         * QueryTables that hold a struct-bearing result column. When found,
         * append a relation source pointing at the function's field result
         * column so the exact source path (e.g. {@code nodes[*].key}) is
         * preserved through the outer projection. Returns {@code true} when
         * the reference was bound and the caller should skip orphan-column
         * fallback.
         */
        private boolean tryAppendStructuredFieldRelation(DataFlowRelationship relation,
                        TObjectName columnName, TTableList tableList) {
                if (relation == null || columnName == null || tableList == null) {
                        return false;
                }
                String fullText = columnName.toString();
                if (fullText == null) return false;
                int firstDot = fullText.indexOf('.');
                if (firstDot < 0) return false;

                String structAlias;
                String fieldName;
                int lastDot = fullText.lastIndexOf('.');
                if (firstDot == lastDot) {
                        structAlias = fullText.substring(0, firstDot);
                        fieldName = fullText.substring(firstDot + 1);
                } else {
                        structAlias = fullText.substring(firstDot + 1, lastDot);
                        fieldName = fullText.substring(lastDot + 1);
                }
                if (structAlias == null || structAlias.isEmpty()) return false;
                if (fieldName == null || fieldName.isEmpty()) return false;

                for (int i = 0; i < tableList.size(); i++) {
                        TTable tt = tableList.getTable(i);
                        if (tt == null) continue;
                        Object tm = modelManager.getModel(tt);
                        if (!(tm instanceof QueryTable)) continue;
                        QueryTable qt = (QueryTable) tm;
                        if (qt.getColumns() == null) continue;
                        for (ResultColumn rc : qt.getColumns()) {
                                if (rc == null || rc.getName() == null) continue;
                                if (!SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, structAlias, rc.getName())) continue;
                                ResultColumn fieldColumn = findStructuredFieldColumn(rc, fieldName);
                                if (fieldColumn != null) {
                                        relation.addSource(new ResultColumnRelationshipElement(fieldColumn));
                                        return true;
                                }
                        }
                }
                return false;
        }

        /**
         * Given a QueryTable result column that aliases a structured generator
         * (e.g. {@code nodes1} backed by Spark {@code explode(from_json(...))}),
         * locate the FunctionResultColumn named {@code fieldName}. The Function
         * model is discovered by walking the existing data-flow relations whose
         * target is the alias column.
         */
        private ResultColumn findStructuredFieldColumn(ResultColumn aliasColumn, String fieldName) {
                if (aliasColumn == null || fieldName == null) return null;
                Relationship[] rels = modelManager.getRelations();
                if (rels == null) return null;
                String normalField = fieldName.trim();
                for (Relationship r : rels) {
                        if (!(r instanceof DataFlowRelationship)) continue;
                        DataFlowRelationship dfr = (DataFlowRelationship) r;
                        if (dfr.getTarget() == null) continue;
                        if (!(dfr.getTarget().getElement() == aliasColumn)) continue;
                        if (dfr.getSources() == null) continue;
                        for (RelationshipElement<?> se : dfr.getSources()) {
                                Object srcElement = se.getElement();
                                if (!(srcElement instanceof ResultColumn)) continue;
                                ResultColumn src = (ResultColumn) srcElement;
                                if (SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, normalField, src.getName())) {
                                        return src;
                                }
                        }
                }
                return null;
        }

        /**
         * Find-or-create a TableColumn carrying a structured display path
         * (e.g. {@code nodes[*].key}) on the given source table. Unlike the
         * star-column {@link #findOrCreateTableStarColumn(Table)}, this does
         * not treat the dotted/bracketed text as a schema-qualified name;
         * the entire path is used as the column display, so existing flat
         * columns named after the leaf field (e.g. {@code key}) do not
         * collide with structured-path columns.
         */
        private TableColumn findOrCreateStructuredPathColumn(Table table,
                        gudusoft.gsqlparser.common.structured.StructuredColumnPath path) {
                String pathDisplay = path == null ? null : path.toDisplayString();
                if (table == null || pathDisplay == null || pathDisplay.isEmpty()) return null;
                // one column per path of the table, by its structural identity (plan section 4.7), not by its display
                FieldNodeKey key = FieldNodeKey.of(table, path.getSegments());
                TableColumn column = structuredPathColumns.get(key);
                if (column == null) {
                        column = new TableColumn(table, pathDisplay);
                        structuredPathColumns.put(key, column);
                }
                return column;
        }

        /** The columns {@link #findOrCreateStructuredPathColumn} made, by table and path. */
        private final Map<FieldNodeKey, TableColumn> structuredPathColumns = new HashMap<FieldNodeKey, TableColumn>();

        /**
         * Whether a reference names a result column. A column with an identity is named by the reference's identity
         * alone; a column without one (an unaliased expression, a synthesized name) by the name service's equality of the
         * two names as written.
         */
        private boolean referencesColumn(TObjectName reference, ResultColumn column) {
                CanonKey columnKey = column.getIdentifierKey();
                return columnKey != null ? columnKey.equals(DlineageUtil.columnKey(reference))
                                : DlineageUtil.sameColumnSegment(DlineageUtil.rawColumnName(reference), column.getName());
        }

        /** Whether the first segment of a reference, as written (a BigQuery struct base), names a result column. */
        private boolean referencesColumnSegment(String segment, ResultColumn column) {
                CanonKey columnKey = column.getIdentifierKey();
                return columnKey != null
                                ? columnKey.equals(DlineageUtil.lexicalColumnKey(getOption().getVendor(), segment))
                                : DlineageUtil.sameColumnSegment(segment, column.getName());
        }

        /**
         * STRUCT tree: links a field read through a CTE or a subquery, {@code customer.address.city} or
         * {@code c.customer.name} where {@code customer} is a column of it, to the column named by the read's base. A
         * result set has no field nodes, so the read comes from that whole column, as a read of {@code customer} does.
         * Matched by its last segment, the read found no column and its edge was lost. A set operation is left to its own
         * path, which already matches a field read by its base.
         *
         * @return whether the reference is such a read and the query has a column named by its base
         */
        private boolean linkStructFieldReadThroughQuery(QueryTable queryTable, TSelectSqlStatement subquery,
                        TObjectName reference, Object modelObject, DataFlowRelationship relation) {
                if (subquery != null && subquery.isCombinedQuery()) {
                        return false;
                }
                ResultColumn column = structFieldReadBaseColumn(reference, queryTable.getColumns());
                if (column == null) {
                        return false;
                }
                column = structFieldReadSource(column, reference);
                if (!column.equals(modelObject)) {
                        relation.addSource(new ResultColumnRelationshipElement(column, reference));
                }
                return true;
        }

        /**
         * Whether {@code column} is a column of a SELECT that joins with USING: a USING column merges both sides, so a
         * single published source does not prove the value passes through unchanged (Mantis 4836).
         */
        private static boolean mergesJoinUsingColumns(ResultColumn column) {
                if (!(column.getResultSet() instanceof SelectResultSet)) {
                        return false;
                }
                TSelectSqlStatement select = ((SelectResultSet) column.getResultSet()).getSelectStmt();
                if (select == null || select.getJoins() == null) {
                        return false;
                }
                for (int i = 0; i < select.getJoins().size(); i++) {
                        TJoin join = select.getJoins().getJoin(i);
                        if (join.getJoinItems() == null) {
                                continue;
                        }
                        for (int j = 0; j < join.getJoinItems().size(); j++) {
                                if (join.getJoinItems().getJoinItem(j).getUsingColumns() != null) {
                                        return true;
                                }
                        }
                }
                return false;
        }

        /**
         * STRUCT tree: what a field read through a CTE or a derived table reads, given the column {@code base} named by
         * the read's base ({@code customer} for {@code customer.address.city}). When that column passes on a table column
         * unchanged, through result columns each with one source and no function on the way, the read is of the field
         * itself: a field node below each result column on the way ({@code customer.address.city}), fed by the next one
         * and the last by the table's field node, so {@code v.city <- orders_raw.customer.address.city}. Otherwise (a
         * function, a STRUCT the query builds, a set operation, a wildcard, a field the DDL does not declare) the whole
         * column {@code base}, as before (Mantis 4836).
         */
        private ResultColumn structFieldReadSource(ResultColumn base, TObjectName reference) {
                gudusoft.gsqlparser.common.structured.StructuredColumnPath read = reference.getFieldPathRead();
                if (base == null || read == null || read.getSegments().isEmpty()
                                || !nestedProfile().buildsDeclaredTree()) {
                        return base;
                }
                ResultColumn built = builtFieldNode(base, read);
                if (built != null) {
                        // a field of a STRUCT the derived table's query built: its own node (Mantis 4893)
                        return built;
                }
                List<ResultColumn> chain = new ArrayList<ResultColumn>();
                Set<Object> visited = Collections.newSetFromMap(new IdentityHashMap<Object, Boolean>());
                Object current = base;
                while (current instanceof ResultColumn) {
                        ResultColumn column = (ResultColumn) current;
                        if (!visited.add(column) || column.getResultSet() instanceof Function || column.isStarColumn()
                                        || column.isStruct() || mergesJoinUsingColumns(column)) {
                                return base;
                        }
                        chain.add(column);
                        Object source = null;
                        for (Relationship relation : modelManager.getRelations()) {
                                if (!(relation instanceof DataFlowRelationship) || relation.getTarget() == null
                                                || relation.getTarget().getElement() != column) {
                                        continue;
                                }
                                if (((DataFlowRelationship) relation).getEffectType() != EffectType.select
                                                || relation.getSources().size() != 1 || source != null) {
                                        return base;
                                }
                                source = ((RelationshipElement<?>) relation.getSources().iterator().next()).getElement();
                        }
                        if (source == null) {
                                return base;
                        }
                        current = source;
                }
                if (!(current instanceof TableColumn)) {
                        return base;
                }
                TableColumn origin = (TableColumn) current;
                List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> segments =
                                new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>();
                TableColumn declared = origin;
                if (origin.isFieldPathNode()) {
                        if (origin.getDeclaredColumn() == null) {
                                return base;
                        }
                        declared = origin.getDeclaredColumn();
                        segments.addAll(origin.getFieldPath().getSegments());
                }
                segments.addAll(read.getSegments());
                TableColumn tableNode = modelFactory.createFieldPath(declared, segments, reference);
                if (tableNode == null) {
                        // the DDL declares no such field: the whole column, as before
                        return base;
                }
                StringBuilder suffix = new StringBuilder();
                for (gudusoft.gsqlparser.common.structured.StructuredPathSegment segment : read.getSegments()) {
                        suffix.append(segment.toDisplayString());
                }
                Object upstream = tableNode;
                for (int i = chain.size() - 1; i >= 0; i--) {
                        ResultColumn column = chain.get(i);
                        // one node per field of the column, by its structural identity (plan section 4.7)
                        ResultColumn node = column.getResultSet().getFieldPathNode(FieldNodeKey.of(column, read.getSegments()));
                        if (node == null) {
                                TSourceToken path = new TSourceToken(column.getName() + suffix);
                                TSourceToken at = reference.getStartToken();
                                if (at != null) {
                                        path.lineNo = at.lineNo;
                                        path.columnNo = at.columnNo;
                                }
                                // a node of its own: never name-matched to a column, so a quoted alias "customer.address.city"
                                // stays the column it is
                                node = modelFactory.createDeterminedResultColumn(column.getResultSet(),
                                                TObjectName.createObjectName(option.getVendor(), EDbObjectType.column, path));
                                node.setStruct(true);
                                column.getResultSet().addFieldPathColumn(node, column, read.getSegments());
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.select);
                                relation.setTarget(new ResultColumnRelationshipElement(node));
                                if (upstream instanceof TableColumn) {
                                        relation.addSource(new TableColumnRelationshipElement((TableColumn) upstream));
                                } else {
                                        relation.addSource(new ResultColumnRelationshipElement((ResultColumn) upstream));
                                }
                        }
                        upstream = node;
                }
                return (ResultColumn) upstream;
        }

        /**
         * STRUCT tree: the column of a CTE or a subquery that a field read through it reads, the one named by the read's
         * base ({@code customer} for {@code customer.address.city}); null when the reference reads a whole column, when
         * the columns have none of that name, and when the read is not proven: its base also names the relation it is read
         * from ({@code c.name FROM q AS c}, which BigQuery reads as ambiguous), or the DDL of the column the CTE passes on
         * has no such field.
         */
        private ResultColumn structFieldReadBaseColumn(TObjectName reference, List<ResultColumn> columns) {
                if (!nestedProfile().buildsDeclaredTree() || reference.getFieldPathRead() == null
                                || reference.getFieldPathBaseToken() == null) {
                        return null;
                }
                String base = reference.getFieldPathBaseToken().toString();
                TTable relation = reference.getSourceTable();
                if (relation != null) {
                        String relationName = !SQLUtil.isEmpty(relation.getAliasName()) ? relation.getAliasName()
                                        : relation.getName();
                        if (relationName != null
                                        && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotTable, base, relationName)) {
                                return null;
                        }
                }
                for (ResultColumn column : columns) {
                        if (!column.isStarColumn() && referencesColumnSegment(base, column)) {
                                return declaresFieldRead(passedOnDeclaredColumn(column), reference.getFieldPathRead()) ? column : null;
                        }
                }
                return null;
        }

        /** Declared types whose values a field read can reach: the STRUCT types, and BigQuery JSON. */
        private static final Set<String> FIELD_READABLE_TYPES = new HashSet<String>(
                        Arrays.asList("struct", "row", "record", "json"));

        /**
         * STRUCT tree: whether the DDL of {@code origin}, a declared column or field node, lets {@code read} reach a field
         * below it: each field of the path is a field its declared type lists, each {@code [*]} the element of a declared
         * array, and a declared column whose type lists no fields is a STRUCT or JSON one. True when nothing is declared
         * to check against ({@code origin} null, or a field of a type GSP does not know).
         */
        private boolean declaresFieldRead(TableColumn origin,
                        gudusoft.gsqlparser.common.structured.StructuredColumnPath read) {
                TableColumn node = origin;
                for (int i = 0; node != null && i < read.getSegments().size(); i++) {
                        gudusoft.gsqlparser.common.structured.StructuredPathSegment segment = read.getSegments().get(i);
                        boolean field = segment.getKind() == gudusoft.gsqlparser.common.structured.StructuredPathSegmentKind.FIELD;
                        if (node.isFieldsDeclared()) {
                                TableColumn next = null;
                                for (TableColumn declared : node.getDeclaredFields()) {
                                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> path = declared.getFieldPath()
                                                        .getSegments();
                                        if (field && DlineageUtil.sameName(ESQLDataObjectType.dotColumn,
                                                        path.get(path.size() - 1).getName(), segment.getName())) {
                                                next = declared;
                                                break;
                                        }
                                }
                                if (next == null) {
                                        return false;
                                }
                                node = next;
                        } else if (node.getDeclaredElement() != null) {
                                if (field) {
                                        return false;
                                }
                                node = node.getDeclaredElement();
                        } else {
                                // a declared column with a scalar type has no fields; a field node carries no type to tell
                                return node.isFieldPathNode() || node.getDataType() == null
                                                || FIELD_READABLE_TYPES.contains(node.getDataType().toLowerCase(Locale.ROOT));
                        }
                }
                return true;
        }

        /**
         * STRUCT tree: the declared column or field node that a result column passes on unchanged, through other result
         * columns, each with one source and no function on the way; null when there is none, or when its table has no
         * DDL.
         */
        private TableColumn passedOnDeclaredColumn(ResultColumn column) {
                Object current = column;
                for (int depth = 0; depth < 32 && current instanceof ResultColumn; depth++) {
                        if (((ResultColumn) current).getResultSet() instanceof Function) {
                                return null;
                        }
                        Object source = null;
                        for (Relationship relation : modelManager.getRelations()) {
                                if (!(relation instanceof DataFlowRelationship) || relation.getTarget() == null
                                                || relation.getTarget().getElement() != current) {
                                        continue;
                                }
                                if (((DataFlowRelationship) relation).getEffectType() != EffectType.select
                                                || relation.getSources().size() != 1 || source != null) {
                                        return null;
                                }
                                source = ((RelationshipElement<?>) relation.getSources().iterator().next()).getElement();
                        }
                        current = source;
                }
                return current instanceof TableColumn && ((TableColumn) current).getTable().isCreateTable()
                                ? (TableColumn) current : null;
        }

        /**
         * STRUCT tree: the relation a read belongs to, given the one a lookup found. A field read TSQLResolver2 could not
         * place belongs to the one relation that declares its base column ({@link #structFieldReadDeclaredOwner}), and a
         * field read that several relations could own belongs to none (plan rule R3). Any other read keeps {@code found}.
         */
        private TTable structFieldReadTable(TTable found, TObjectName reference, TTableList tables) {
                TTable declaredOwner = structFieldReadDeclaredOwner(reference, tables);
                if (declaredOwner != null) {
                        return declaredOwner;
                }
                return found != null && isUndecidedFieldRead(reference) ? null : found;
        }

        /**
         * STRUCT tree: the relation of {@code tables} that owns a field read TSQLResolver2 could not place, such as BigQuery
         * {@code customer.address.city FROM orders_raw o, z}, whose table is then only the parse's guess: the one relation
         * that declares the base column, by DDL or as a column of a CTE or a subquery, or else the one relation that can
         * have it, when the others are declared without it. Null when the read is placed, ambiguous, or not owned by
         * exactly one relation.
         */
        private TTable structFieldReadDeclaredOwner(TObjectName reference, TTableList tables) {
                if (!nestedProfile().buildsDeclaredTree() || tables == null
                                || reference.getFieldPathBaseToken() == null || reference.getFieldPathRead() == null
                                || reference.getResolution() == null || reference.getResolution().isExactMatch()
                                || reference.getResolution().isAmbiguous()) {
                        return null;
                }
                String base = reference.getFieldPathBaseToken().toString();
                TTable declaring = null, possible = null;
                int declaringCount = 0, possibleCount = 0;
                for (int i = 0; i < tables.size(); i++) {
                        TTable table = tables.getTable(i);
                        Object model = modelManager.getModel(table);
                        Boolean has = null;   // true: declares the base; false: declared without it; null: unknown
                        if (model instanceof Table) {
                                Table tableModel = (Table) model;
                                if (tableModel.isCreateTable()) {
                                        has = Boolean.FALSE;
                                        for (TableColumn column : tableModel.getColumns()) {
                                                if (DlineageUtil.sameName(ESQLDataObjectType.dotColumn, column.getName(), base)) {
                                                        has = Boolean.TRUE;
                                                        break;
                                                }
                                        }
                                }
                        } else if (model instanceof ResultSet && !(model instanceof Function)) {
                                has = Boolean.FALSE;
                                for (ResultColumn column : ((ResultSet) model).getColumns()) {
                                        if (column.isStarColumn()) {
                                                has = null;
                                        } else if (referencesColumnSegment(base, column)) {
                                                has = Boolean.TRUE;
                                                break;
                                        }
                                }
                        } else {
                                continue;
                        }
                        if (Boolean.TRUE.equals(has)) {
                                declaring = table;
                                declaringCount++;
                        } else if (has == null) {
                                possible = table;
                                possibleCount++;
                        }
                }
                if (declaringCount == 1) {
                        return declaring;
                }
                return declaringCount == 0 && possibleCount == 1 ? possible : null;
        }

        /**
         * The key two published columns of one result set collide on, which is when the output qualifies them by
         * table: the identity for an identifier, the text for a label (an expression, a literal).
         */
        private static Object publishedColumnKey(ResultColumn column) {
                // Two spellings of one name (HANA sp.Position and sp.POSITION) are one column and collide; a literal 'Name'
                // beside the column Name is not that column. An alias used twice (x, shown as x and x(1)) is one name twice.
                CanonKey key = column.getIdentifierKey();
                if (key != null) {
                        return key;
                }
                // A field path (BigQuery a.left.Name) publishes its leaf: two leaves the vendor reads as one name collide.
                CanonKey leaf = DlineageUtil.fieldLeafKey(columnObjectName(column));
                return leaf != null ? leaf : ModelLabelKey.of(ModelLabelKey.Kind.SYNTHETIC, column.getName());
        }

        /** The parsed name a result column was made from, when it was made from one. */
        private static TObjectName columnObjectName(ResultColumn column) {
                Object object = column.getColumnObject();
                if (object instanceof TObjectName) {
                        return (TObjectName) object;
                }
                if (object instanceof TResultColumn && ((TResultColumn) object).getExpr() != null
                                && ((TResultColumn) object).getExpr().getExpressionType() == EExpressionType.simple_object_name_t) {
                        return ((TResultColumn) object).getExpr().getObjectOperand();
                }
                return null;
        }

        /** Whether a query column and a table column are one column: by identity when both have one, else by name. */
        private static boolean sameModelColumn(Column a, Column b) {
                if (a.getIdentifierKey() != null && b.getIdentifierKey() != null) {
                        return a.getIdentifierKey().equals(b.getIdentifierKey());
                }
                return DlineageUtil.sameColumnSegment(a.getName(), b.getName());
        }

        /** The name of a copy of a model column: a synthesized star for a star, else a name with the given text. */
        private static TObjectName copyColumnName(Column source, String text) {
                if (source.isStarColumn()) {
                        return DlineageUtil.syntheticStarName();
                }
                return Column.nameOfColumn(source, text);
        }

        /** Whether a select-list item is a star ({@code *}, {@code t.*}), by the parse. */
        /**
         * STRUCT tree: the columns an INSERT without a column list fills by position. A select item that builds a STRUCT,
         * or an array of STRUCTs, yields one result column per field ({@code struct(a, b) AS nest1} gives
         * {@code nest1.a} and {@code nest1.b}), so when the select list has exactly one result column per declared leaf
         * field, each STRUCT column with declared fields takes one position per leaf field, depth first, and an array of
         * STRUCTs one per leaf field of its element. Otherwise, and outside the STRUCT tree, the table's columns.
         */
        private List<TableColumn> insertPositionalColumns(Table table, List<ResultColumn> items) {
                if (!nestedProfile().buildsDeclaredTree() || !table.isCreateTable()) {
                        return table.getColumns();
                }
                List<TableColumn> leaves = new ArrayList<TableColumn>();
                for (TableColumn column : table.getColumns()) {
                        addDeclaredLeaves(column, leaves);
                }
                return leaves.size() != table.getColumns().size() && leaves.size() == items.size() ? leaves
                                : table.getColumns();
        }

        /** The declared leaf fields below {@code node}, depth first; {@code node} itself when its fields are not declared. */
        private static void addDeclaredLeaves(TableColumn node, List<TableColumn> leaves) {
                List<TableColumn> fields = node.getDeclaredFields();
                if (fields.isEmpty()) {
                        TableColumn element = node.getDeclaredElement();
                        if (element != null && !element.getDeclaredFields().isEmpty()) {
                                fields = element.getDeclaredFields();
                        }
                }
                if (fields.isEmpty()) {
                        leaves.add(node);
                        return;
                }
                for (TableColumn field : fields) {
                        addDeclaredLeaves(field, leaves);
                }
        }

        /**
         * The columns of {@code table} an item of an array constructor reads, {@code ARRAY[customer.customer_id]}: the field
         * path node it reads in the STRUCT tree, else every column whose name its name matches, as this was always found.
         */
        /** The name of an unaliased array item: the last field it reads, else its column (Mantis 4833). */
        private static String unaliasedArrayItemName(TObjectName item) {
                gudusoft.gsqlparser.common.structured.StructuredColumnPath read = item.getFieldPathRead();
                if (read != null && !read.getSegments().isEmpty()) {
                        gudusoft.gsqlparser.common.structured.StructuredPathSegment last = read.getSegments().get(read.getSegments().size() - 1);
                        if (last.getKind() == gudusoft.gsqlparser.common.structured.StructuredPathSegmentKind.FIELD && last.getName() != null) {
                                return last.getName();
                        }
                }
                return item.getColumnNameOnly();
        }

        private List<TableColumn> arrayItemSources(Table table, TObjectName item) {
                List<TableColumn> sources = new ArrayList<TableColumn>();
                if (nestedProfile().buildsDeclaredTree() && item.getFieldPathRead() != null) {
                        TableColumn node = modelFactory.createTableColumn(table, item, false);
                        if (node != null) {
                                sources.add(node);
                        }
                        return sources;
                }
                for (TableColumn column : table.getColumns()) {
                        if (DlineageUtil.sameColumnName(item.toString(), column.getName())) {
                                sources.add(column);
                        }
                }
                return sources;
        }

        /**
         * Whether {@code star} is a bare {@code *} over several tables, as in {@code SELECT * FROM a JOIN b}. It reads every
         * one of them, while {@code getSourceTable()} names only one, so expanding that table's known columns alone drops
         * the others' (Mantis 4970: in a branch of a UNION the outer query then read the wrong column by position).
         */
        private static boolean starReadsSeveralTables(TObjectName star) {
                List<TTable> tables = star.getSourceTableList();
                return star.getTableToken() == null && tables != null && tables.size() > 1;
        }

        /**
         * The column of a view or table that receives {@code source}, one of the result columns an item is bound to. The *
         * among them, of a star over a join that expanded its other tables (Mantis 4981), is received by the item's own
         * {@code *}, a star that keeps the names read through it, as an item bound to its star is received; any other
         * column by its name.
         */
        private TableColumn itemColumnTarget(Table table, ResultColumn source) {
                TObjectName star = source.isStarColumn() && source.getColumnObject() instanceof TResultColumn
                                ? ((TResultColumn) source.getColumnObject()).getFieldAttr() : null;
                if (star == null || !DlineageUtil.isWildcard(star)) {
                        return modelFactory.createInsertTableColumn(table, source);
                }
                TableColumn target = modelFactory.createInsertTableColumn(table, star);
                if (target != null && target.isStarColumn() && source.hasStarLinkColumn()) {
                        target.shareStarLinksFrom(source);
                }
                return target;
        }

        /**
         * The result columns of {@code item} in {@code resultSet}, in FROM order, keyed by name as an expanded star's are.
         * {@code star} is the wildcard among them; a writer reaches it only by iterating, never by its key, so it takes a
         * key no column of the item has: a column a table declares as {@code [*]} keeps the key {@code *} (Codex review of
         * Mantis 4981).
         */
        private static LinkedHashMap<String, ResultColumn> itemColumns(ResultSet resultSet, TResultColumn item,
                        ResultColumn star) {
                Set<String> names = new HashSet<String>();
                for (ResultColumn column : resultSet.getColumns()) {
                        if (column.getColumnObject() == item && column != star) {
                                names.add(column.getName());
                        }
                }
                String starKey = star.getName();
                for (int n = 1; names.contains(starKey); n++) {
                        starKey = star.getName() + "#" + n;
                }
                LinkedHashMap<String, ResultColumn> columns = new LinkedHashMap<String, ResultColumn>();
                for (ResultColumn column : resultSet.getColumns()) {
                        if (column.getColumnObject() == item) {
                                columns.put(column == star ? starKey : column.getName(), column);
                        }
                }
                return columns;
        }

        /** The star {@link #analyzeStarOfTables} analyzes, and the only tables it reads; null otherwise. */
        private TObjectName starOfTables;
        private List<TTable> starOfTablesRead;

        /**
         * Analyzes {@code column}, the item {@code star} of a {@code SELECT *} over a join, as a read of {@code tables}
         * only: the tables of the join whose columns are not known, when the others' columns were expanded into result
         * columns of their own (Mantis 4981). The restriction is keyed by the star node, so a star of a derived table this
         * analysis reaches reads its own tables.
         */
        private void analyzeStarOfTables(TResultColumn column, TObjectName star, List<TTable> tables) {
                TObjectName outerStar = starOfTables;
                List<TTable> outerTables = starOfTablesRead;
                starOfTables = star;
                starOfTablesRead = tables;
                try {
                        analyzeResultColumn(column, EffectType.select);
                } finally {
                        starOfTables = outerStar;
                        starOfTablesRead = outerTables;
                }
        }

        /**
         * Expands {@code column}, a star of a branch of a set operation, from the known columns of {@code starTables}, the
         * tables it reads in FROM order: a table the script creates or a determined result set. The other branches and the
         * query reading the set operation pair its columns by position, so each table's columns keep theirs (Mantis 4970).
         * A later table's column spelled like an earlier one's is the same column when a USING or NATURAL join merges them,
         * and is otherwise renamed {@code name1}, as in a plain select list. Returns false, having done nothing, when a
         * table's columns are not known; the star is then left to its star links.
         */
        private boolean expandSetBranchStar(TSelectSqlStatement stmt, ResultSet resultSetModel, Object queryModel,
                        TResultColumn column, List<TTable> starTables,
                        Map<String, Pair<String, TExpression>> replaceAsIdentifierMap, Map<String, TObjectName> replaceColumnMap) {
                for (TTable sourceTable : starTables) {
                        if (!columnsKnown(sourceTable)) {
                                return false;
                        }
                }
                // the spellings earlier tables published: createStarResultColumn keys a star's columns by them
                Set<String> earlierNames = new HashSet<String>();
                Set<String> names = new HashSet<String>();
                List<TTable> earlierTables = new ArrayList<TTable>();
                for (TTable sourceTable : starTables) {
                        expandSetBranchStarTable(stmt, resultSetModel, queryModel, column, sourceTable, replaceAsIdentifierMap,
                                        replaceColumnMap, earlierNames, names, earlierTables);
                }
                return true;
        }

        /** Whether the columns of {@code table} are known: a table the script creates or a determined result set. */
        private boolean columnsKnown(TTable table) {
                Object tableModel = modelManager.getModel(table);
                return tableModel instanceof Table && ((Table) tableModel).isCreateTable()
                                || tableModel instanceof ResultSet && ((ResultSet) tableModel).isDetermined();
        }

        /**
         * Mantis 4975: the tables of {@code star}, a star over a join in a branch of a set operation, to expand into result
         * columns of their own before the star reads the rest: the tables the script declares, when the others are one run
         * of the join, so that the star stands where their columns do. Empty when every table, or none, is declared, or when
         * the other tables are apart (the star would stand for both places at once). A derived table stays in the star: its
         * columns, read through the star by name, would also take the star's tables (Codex review).
         */
        private List<TTable> splitSetBranchStarTables(List<TTable> starTables) {
                int first = -1;
                int last = -1;
                for (int k = 0; k < starTables.size(); k++) {
                        if (!columnsDeclared(starTables.get(k))) {
                                if (first < 0) {
                                        first = k;
                                }
                                last = k;
                        }
                }
                if (first < 0 || last - first + 1 == starTables.size()) {
                        return Collections.emptyList();
                }
                List<TTable> known = new ArrayList<TTable>();
                for (int k = 0; k < starTables.size(); k++) {
                        if (columnsDeclared(starTables.get(k))) {
                                if (k > first && k < last) {
                                        return Collections.emptyList();
                                }
                                known.add(starTables.get(k));
                        }
                }
                return known;
        }

        /** Whether {@code table} is a table the script declares. */
        private boolean columnsDeclared(TTable table) {
                Object tableModel = modelManager.getModel(table);
                return tableModel instanceof Table && ((Table) tableModel).isCreateTable();
        }

        /**
         * Whether a join of {@code stmt}'s own FROM clause merges columns, USING or NATURAL: a merged column stands before
         * the other columns of the tables it merges, not in their order (Codex review of Mantis 4975).
         */
        private boolean mergesJoinColumns(TSelectSqlStatement stmt) {
                if (!usingColumnsOf(stmt).isEmpty()) {
                        return true;
                }
                if (stmt.joins != null) {
                        for (int i = 0; i < stmt.joins.size(); i++) {
                                TJoin join = stmt.joins.getJoin(i);
                                for (int j = 0; join != null && join.getJoinItems() != null && j < join.getJoinItems().size(); j++) {
                                        TJoinItem item = join.getJoinItems().getJoinItem(j);
                                        if (item != null && isNaturalJoin(item.getJoinType())) {
                                                return true;
                                        }
                                }
                        }
                }
                Deque<TTable> pending = new ArrayDeque<TTable>();
                if (stmt.getRelations() != null) {
                        pending.addAll(stmt.getRelations());
                }
                while (!pending.isEmpty()) {
                        TTable relation = pending.pop();
                        if (relation == null || relation.getTableType() != ETableSource.join || relation.getJoinExpr() == null) {
                                continue;
                        }
                        TJoinExpr join = relation.getJoinExpr();
                        if (isNaturalJoin(join.getJointype())) {
                                return true;
                        }
                        if (join.getLeftTable() != null) {
                                pending.push(join.getLeftTable());
                        }
                        if (join.getRightTable() != null) {
                                pending.push(join.getRightTable());
                        }
                }
                return false;
        }

        private static boolean isNaturalJoin(EJoinType type) {
                return type != null && type.name().startsWith("natural");
        }

        /**
         * Expands the columns of {@code sourceTable}, one of the tables {@code column}, a star of a branch of a set
         * operation, reads, into result columns of the branch ({@link #expandSetBranchStar}); {@code earlierNames},
         * {@code names} and {@code earlierTables} carry the spellings and tables of the tables before it.
         */
        private void expandSetBranchStarTable(TSelectSqlStatement stmt, ResultSet resultSetModel, Object queryModel,
                        TResultColumn column, TTable sourceTable, Map<String, Pair<String, TExpression>> replaceAsIdentifierMap,
                        Map<String, TObjectName> replaceColumnMap, Set<String> earlierNames, Set<String> names,
                        List<TTable> earlierTables) {
                Object tableModel = modelManager.getModel(sourceTable);
                if (tableModel instanceof Table) {
                        for (TableColumn tableColumn : ((Table) tableModel).getColumns()) {
                                if (exceptedByStar(column, tableColumn.getName(), tableColumn.isStruct())) {
                                        continue;
                                }
                                if (replaceAsIdentifierMap.containsKey(tableColumn.getName())) {
                                        replaceStarColumn(resultSetModel, tableColumn.getName(), replaceAsIdentifierMap,
                                                        replaceColumnMap);
                                        continue;
                                }
                                String name = tableColumn.getName();
                                ResultColumn resultColumn;
                                if (!earlierNames.contains(name)) {
                                        resultColumn = modelFactory.createStarResultColumn(resultSetModel, column, name, tableColumn);
                                } else if (isUsingMerged(stmt, tableColumn, sourceTable, earlierTables)) {
                                        // one column of the join: the column an earlier table published reads this table's too
                                        resultColumn = modelFactory.createStarResultColumn(resultSetModel, column, name);
                                } else {
                                        name = unpublishedName(name, names);
                                        resultColumn = modelFactory.createStarResultColumn(resultSetModel, column, name);
                                        resultColumn.inheritStarColumn(tableColumn);
                                }
                                names.add(name);
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.select);
                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                        }
                } else {
                        for (ResultColumn tableColumn : ((ResultSet) tableModel).getColumns()) {
                                if (exceptedByStar(column, tableColumn.getName(), tableColumn.isStruct())) {
                                        continue;
                                }
                                if (replaceAsIdentifierMap.containsKey(tableColumn.getName())) {
                                        replaceStarColumn(resultSetModel, tableColumn.getName(), replaceAsIdentifierMap,
                                                        replaceColumnMap);
                                        continue;
                                }
                                boolean referenced = tableColumn.getRefColumnName() != null;
                                ResultSet target = referenced ? (ResultSet) queryModel : resultSetModel;
                                String name = referenced ? tableColumn.getRefColumnName() : tableColumn.getName();
                                ResultColumn resultColumn;
                                if (!earlierNames.contains(name)) {
                                        resultColumn = modelFactory.createStarResultColumn(target, column, name, tableColumn);
                                } else {
                                        name = unpublishedName(name, names);
                                        resultColumn = modelFactory.createStarResultColumn(target, column, name);
                                        resultColumn.inheritStarColumn(tableColumn);
                                }
                                names.add(name);
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.select);
                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                        }
                }
                earlierNames.addAll(names);
                earlierTables.add(sourceTable);
        }

        /**
         * Whether every branch of {@code setOperation} is one {@code *}, without EXCEPT or REPLACE, of the same tables in the
         * same order. A set operation takes its column names from its first branch and pairs the others by position; when
         * the branches read the same tables the same way, a column has the same position and name in each, so a name the
         * set operation's {@code *} may hold is the column of that name in every branch (Mantis 4974). Otherwise another
         * branch's column at that position may have any name.
         */
        private boolean branchesReadTheSameTables(TSelectSqlStatement setOperation) {
                if (setOperation == null) {
                        return false;
                }
                List<Object> first = null;
                Deque<TSelectSqlStatement> stack = new ArrayDeque<TSelectSqlStatement>();
                stack.push(setOperation);
                while (!stack.isEmpty()) {
                        TSelectSqlStatement branch = stack.pop();
                        if (branch.getSetOperatorType() != ESetOperatorType.none) {
                                if (branch.getRightStmt() != null) {
                                        stack.push(branch.getRightStmt());
                                }
                                if (branch.getLeftStmt() != null) {
                                        stack.push(branch.getLeftStmt());
                                }
                                continue;
                        }
                        TResultColumnList items = branch.getResultColumnList();
                        if (items == null || items.size() != 1 || !isStarItem(items.getResultColumn(0))) {
                                return false;
                        }
                        TResultColumn star = items.getResultColumn(0);
                        if (star.getExceptColumnList() != null || (star.getReplaceExprAsIdentifiers() != null
                                        && !star.getReplaceExprAsIdentifiers().isEmpty())) {
                                return false;
                        }
                        List<TTable> tables = star.getFieldAttr().getSourceTableList();
                        if (tables == null || tables.isEmpty()) {
                                return false;
                        }
                        List<Object> models = new ArrayList<Object>();
                        for (TTable table : tables) {
                                Object model = modelManager.getModel(table);
                                if (!(model instanceof Table)) {
                                        return false;
                                }
                                models.add(model);
                        }
                        if (first == null) {
                                first = models;
                        } else if (first.size() != models.size()) {
                                return false;
                        } else {
                                for (int i = 0; i < models.size(); i++) {
                                        if (first.get(i) != models.get(i)) {
                                                return false;
                                        }
                                }
                        }
                }
                return first != null;
        }

        /** {@code name} followed by the first number that makes it a name the star has not published yet. */
        private static String unpublishedName(String name, Set<String> published) {
                for (int index = 1;; index++) {
                        if (!published.contains(name + index)) {
                                return name + index;
                        }
                }
        }

        /** Whether the EXCEPT/EXCLUDE list of a star drops the column {@code name}, or a field of it when it is a struct. */
        private static boolean exceptedByStar(TResultColumn column, String name, boolean struct) {
                if (column.getExceptColumnList() == null) {
                        return false;
                }
                for (TObjectName objectName : column.getExceptColumnList()) {
                        if (DlineageUtil.sameColumnName(objectName.toString(), name)) {
                                return true;
                        }
                }
                if (struct) {
                        for (String part : SQLUtil.parseNames(name)) {
                                for (TObjectName objectName : column.getExceptColumnList()) {
                                        if (DlineageUtil.sameColumnName(objectName.toString(), part)) {
                                                return true;
                                        }
                                }
                        }
                }
                return false;
        }

        /** The column {@code * REPLACE (expr AS name)} gives in place of the star's column {@code name}. */
        private void replaceStarColumn(ResultSet resultSetModel, String name,
                        Map<String, Pair<String, TExpression>> replaceAsIdentifierMap, Map<String, TObjectName> replaceColumnMap) {
                Pair<String, TExpression> expr = replaceAsIdentifierMap.get(name);
                ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel, replaceColumnMap.get(name));
                Transform transform = new Transform();
                transform.setType(Transform.EXPRESSION);
                TObjectName expression = new TObjectName();
                expression.setString(expr.first);
                transform.setCode(expression);
                resultColumn.setTransform(transform);
                analyzeResultColumnExpressionRelation(resultColumn, expr.second);
        }

        private static boolean isStarItem(TResultColumn item) {
                return item != null && item.getExpr() != null
                                && item.getExpr().getExpressionType() == EExpressionType.simple_object_name_t
                                && DlineageUtil.isStarName(item.getExpr().getObjectOperand());
        }

        /** Whether a model column's parse node (a name or a select-list item) is a star. */
        private static boolean isStarNode(TParseTreeNode node) {
                return node instanceof TObjectName ? DlineageUtil.isStarName((TObjectName) node)
                                : node instanceof TResultColumn && isStarItem((TResultColumn) node);
        }

        /** Whether a model column's parse node is an unqualified star ({@code *}, not {@code t.*}). */
        private static boolean isBareStarNode(TParseTreeNode node) {
                TObjectName name = node instanceof TObjectName ? (TObjectName) node
                                : node instanceof TResultColumn && isStarItem((TResultColumn) node)
                                                ? ((TResultColumn) node).getExpr().getObjectOperand() : null;
                return name != null && DlineageUtil.isStarName(name) && name.getTableToken() == null;
        }

        /** Whether a select list has a star item. */
        private static boolean hasStarItem(TResultColumnList list) {
                for (int i = 0; list != null && i < list.size(); i++) {
                        if (isStarItem(list.getResultColumn(i))) {
                                return true;
                        }
                }
                return false;
        }

        /** Whether a select list's last item is a star. */
        private static boolean lastItemIsStar(TResultColumnList list) {
                return list != null && list.size() > 0 && isStarItem(list.getResultColumn(list.size() - 1));
        }

        /** The table's star column, created when the table has none. */
        private TableColumn findOrCreateTableStarColumn(Table table) {
                for (TableColumn tc : table.getColumns()) {
                        if (tc.isStarColumn()) return tc;
                }
                return modelFactory.createTableColumn(table, DlineageUtil.syntheticStarName(), true);
        }

        /** The result set's star column, created when it has none. */
        private ResultColumn findOrCreateResultStarColumn(ResultSet resultSet) {
                for (ResultColumn rc : resultSet.getColumns()) {
                        if (rc.isStarColumn()) return rc;
                }
                return modelFactory.createResultColumn(resultSet, DlineageUtil.syntheticStarName());
        }

        private void getFunctionExpressions(List<TExpression> directExpressions, List<TExpression> indirectExpressions,
                        TFunctionCall functionCall) {
                if (functionCall.getArgs() != null) {
                        for (int k = 0; k < functionCall.getArgs().size(); k++) {
                                TExpression expr = functionCall.getArgs().getExpression(k);
                                if(FunctionUtility.isDirectRelation(option.getVendor(), functionCall.getFunctionName().toString(),  functionCall.getArgs().size(), k)) {
                                        directExpressions.add(expr);
                                }
                                if(FunctionUtility.isIndirectRelation(option.getVendor(), functionCall.getFunctionName().toString(),  functionCall.getArgs().size(), k)) {
                                        if("DECODE".equalsIgnoreCase(functionCall.getFunctionName().toString()) && option.getVendor() == EDbVendor.dbvoracle) {
                                                if(option.isShowCaseWhenAsDirect()) {
                                                        directExpressions.add(expr);
                                                        continue;
                                                }
                                        }
                                        indirectExpressions.add(expr);
                                }
                        }
                }
                collectOracleXmlFunctionExpressions(functionCall, directExpressions, indirectExpressions);
                collectArrayAggOrderByExpressions(functionCall, directExpressions, indirectExpressions);
                collectAggregateOrderByExpressions(functionCall, directExpressions, indirectExpressions);
                if (functionCall.getTrimArgument() != null) {
                        TTrimArgument args = functionCall.getTrimArgument();
                        TExpression expr = args.getStringExpression();
                        if (expr != null) {
                                directExpressions.add(expr);
                        }
                        expr = args.getTrimCharacter();
                        if (expr != null) {
                                directExpressions.add(expr);
                        }
                }

                if (functionCall.getAgainstExpr() != null) {
                        directExpressions.add(functionCall.getAgainstExpr());
                }
                // split(s, ':')[n]: the element the subscript selects depends on n (Mantis 4817)
                directExpressions.addAll(functionCall.getSubscriptExpressions());
//              if (functionCall.getBetweenExpr() != null) {
//                      directExpressions.add(functionCall.getBetweenExpr());
//              }
                if (functionCall.getExpr1() != null) {
                        directExpressions.add(functionCall.getExpr1());
                }
                if (functionCall.getExpr2() != null) {
                        directExpressions.add(functionCall.getExpr2());
                }
                if (functionCall.getExpr3() != null) {
                        directExpressions.add(functionCall.getExpr3());
                }
                if (functionCall.getParameter() != null) {
                        directExpressions.add(functionCall.getParameter());
                }
                if (functionCall.getWindowDef() != null && functionCall.getWindowDef().getPartitionClause() != null) {
                        TExpressionList args = functionCall.getWindowDef().getPartitionClause().getExpressionList();
                        if (args != null) {
                                for (int k = 0; k < args.size(); k++) {
                                        TExpression expr = args.getExpression(k);
                                        if (expr != null) {
                                                indirectExpressions.add(expr);
                                        }
                                }
                        }
                }
                if (functionCall.getWindowDef() != null && functionCall.getWindowDef().getOrderBy() != null) {
                        TOrderByItemList orderByList = functionCall.getWindowDef().getOrderBy().getItems();
                        for (int i = 0; i < orderByList.size(); i++) {
                                TOrderByItem element = orderByList.getOrderByItem(i);
                                TExpression expression = element.getSortKey();
                                indirectExpressions.add(expression);
                        }
                }
                if (functionCall.getWithinGroup() != null && functionCall.getWithinGroup().getOrderBy() != null) {
                        TOrderByItemList orderByList = functionCall.getWithinGroup().getOrderBy().getItems();
                        for (int i = 0; i < orderByList.size(); i++) {
                                TOrderByItem element = orderByList.getOrderByItem(i);
                                TExpression expression = element.getSortKey();
                                indirectExpressions.add(expression);
                        }
                }
                if (functionCall.getCallTarget() != null) {
                        directExpressions.add(functionCall.getCallTarget().getExpr());
                }
                if (functionCall.getFieldValues() != null) {
                        for (int k = 0; k < functionCall.getFieldValues().size(); k++) {
                                TExpression expr = functionCall.getFieldValues().getResultColumn(k).getExpr();
                                directExpressions.add(expr);
                        }
                }
                if (functionCall instanceof TJsonObjectFunction) {
                        TJsonObjectFunction jsonObject = (TJsonObjectFunction)functionCall;
                        for (int k = 0; k < jsonObject.getKeyValues().size(); k++) {
                                TExpression expr = jsonObject.getKeyValues().get(k).getValue();
                                directExpressions.add(expr);
                        }
                }
                if (functionCall.getGroupConcatParam() != null) {
                        for (int k = 0; k < functionCall.getGroupConcatParam().getExprList().size(); k++) {
                                TExpression expr = functionCall.getGroupConcatParam().getExprList().getExpression(k);
                                directExpressions.add(expr);
                        }
                }
        }

        private void getFunctionExpressions(List<TExpression> directExpressions, List<TExpression> indirectExpressions,
                                                                                TFunctionCall functionCall, int argumentIndex) {
                if (functionCall.getArgs() != null && argumentIndex < functionCall.getArgs().size()) {
                        TExpression expr = functionCall.getArgs().getExpression(argumentIndex);
                        if (FunctionUtility.isDirectRelation(option.getVendor(), functionCall.getFunctionName().toString(), functionCall.getArgs().size(), argumentIndex)) {
                                directExpressions.add(expr);
                        }
                        if (FunctionUtility.isIndirectRelation(option.getVendor(), functionCall.getFunctionName().toString(), functionCall.getArgs().size(), argumentIndex)) {
                                indirectExpressions.add(expr);
                        }
                }
        }
        
        private void getFunctionExpressions(List<TExpression> directExpressions, List<TExpression> indirectExpressions,
                        TCallStatement functionCall, int argumentIndex) {
                if (functionCall.getArgs() != null && argumentIndex < functionCall.getArgs().size()) {
                        TExpression expr = functionCall.getArgs().getExpression(argumentIndex);
                        if (FunctionUtility.isDirectRelation(option.getVendor(), functionCall.getRoutineName().toString(),
                                        functionCall.getArgs().size(), argumentIndex)) {
                                directExpressions.add(expr);
                        }
                        if (FunctionUtility.isIndirectRelation(option.getVendor(), functionCall.getRoutineName().toString(),
                                        functionCall.getArgs().size(), argumentIndex)) {
                                indirectExpressions.add(expr);
                        }
                }
        }

        private void getFunctionExpressions(List<TExpression> directExpressions, List<TExpression> indirectExpressions,
                        TDb2CallStmt functionCall, int argumentIndex) {
                if (functionCall.getParameters() != null && argumentIndex < functionCall.getParameters().size()) {
                        TExpression expr = functionCall.getParameters().getExpression(argumentIndex);
                        if (FunctionUtility.isDirectRelation(option.getVendor(), functionCall.getProcedureName().toString(),
                                        functionCall.getParameters().size(), argumentIndex)) {
                                directExpressions.add(expr);
                        }
                        if (FunctionUtility.isIndirectRelation(option.getVendor(), functionCall.getProcedureName().toString(),
                                        functionCall.getParameters().size(), argumentIndex)) {
                                indirectExpressions.add(expr);
                        }
                }
        }

        private void getFunctionExpressions(List<TExpression> directExpressions, List<TExpression> indirectExpressions,
                                                                                TMssqlExecute functionCall, String argumentName, int argumentIndex) {
                if (functionCall.getParameters() != null) {
                        for (int i = 0; i < functionCall.getParameters().size(); i++) {
                                TExecParameter param = functionCall.getParameters().getExecParameter(i);
                                if (param.getParameterName() != null) {
                                        if (DlineageUtil.compareColumnIdentifier(param.getParameterName().toString(), argumentName)) {
                                                TExpression expr = param.getParameterValue();
                                                directExpressions.add(expr);
                                        }
                                } else if (i == argumentIndex) {
                                        TExpression expr = param.getParameterValue();
                                        directExpressions.add(expr);
                                }
                        }
                }
        }

        private void analyzeJoin(TJoin join, EffectType effectType) {
                if (join.getJoinItems() != null) {
                        for (int j = 0; j < join.getJoinItems().size(); j++) {
                                TJoinItem joinItem = join.getJoinItems().getJoinItem(j);
                                TExpression expr = joinItem.getOnCondition();
                                if (expr != null) {
                                        analyzeFilterCondition(null, expr, joinItem.getJoinType(), JoinClauseType.on, effectType);
                                }
                        }
                }

                if (join.getJoin() != null) {
                        analyzeJoin(join.getJoin(), effectType);
                }
        }

        private TSelectSqlStatement getParentSetSelectStmt(TSelectSqlStatement stmt) {
                TCustomSqlStatement parent = stmt.getParentStmt();
                if (parent == null)
                        return null;
                if (parent.getStatements() != null) {
                        for (int i = 0; i < parent.getStatements().size(); i++) {
                                TCustomSqlStatement temp = parent.getStatements().get(i);
                                if (temp instanceof TSelectSqlStatement) {
                                        TSelectSqlStatement select = (TSelectSqlStatement) temp;
                                        if (select.getLeftStmt() == stmt || select.getRightStmt() == stmt)
                                                return select;
                                }
                        }
                }
                if (parent instanceof TSelectSqlStatement) {
                        TSelectSqlStatement select = (TSelectSqlStatement) parent;
                        if (select.getLeftStmt() == stmt || select.getRightStmt() == stmt)
                                return select;
                }
                return null;
        }

        private void createSelectSetResultColumns(SelectSetResultSet resultSet, TSelectSqlStatement stmt) {
                if (stmt.getSetOperatorType() != ESetOperatorType.none) {
                        createSelectSetResultColumns(resultSet, stmt.getLeftStmt());
                } else {
                        TResultColumnList columnList = stmt.getResultColumnList();
                        ResultSet subqueryResultSet = (ResultSet) modelManager.getModel(columnList);
                        if(subqueryResultSet!=null && subqueryResultSet.isDetermined()) {
                                for (int j = 0; j < subqueryResultSet.getColumns().size(); j++) {
                                        ResultColumn tableColumn = subqueryResultSet.getColumns().get(j);
                                        String name = tableColumn.getRefColumnName() != null
                                                        ? tableColumn.getRefColumnName() : tableColumn.getName();
                                        boolean emptyName = SQLUtil.isEmpty(name);
                                        if (emptyName) {
                                                // Empty delimited identifiers have no normalized name. Keep
                                                // their set-column ordinal and recover the lexical spelling.
                                                name = tableColumn.getFullName();
                                        }
                                        TObjectName columnName = copyColumnName(tableColumn, name == null ? "" : name);
                                        if (emptyName && tableColumn.getColumnObject() != null) {
                                                // Reuse the real span instead of publishing a synthetic 1:1
                                                // coordinate for the recovered spelling.
                                                columnName.setStartTokenDirectly(tableColumn.getColumnObject().getStartToken());
                                                columnName.setEndTokenDirectly(tableColumn.getColumnObject().getEndToken());
                                        }
                                        modelFactory.createDeterminedResultColumn(resultSet, columnName).inheritIdentifier(tableColumn);
                                }
                                resultSet.setDetermined(true);
                                return;
                        }
                        
                        boolean isDetermined = true;
                        for (int i = 0; i < columnList.size(); i++) {
                                TResultColumn column = columnList.getResultColumn(i);
                                
                                if (isStarItem(column)) {
                                        TObjectName columnObject = column.getFieldAttr();
                                        TTable sourceTable = columnObject.getSourceTable();
                                        if (starReadsSeveralTables(columnObject)) {
                                                // one select-set column for the star, as for a star of unknown columns (Mantis 4970)
                                                sourceTable = null;
                                                isDetermined = false;
                                        }
                                        if (sourceTable != null) {
                                                Object tableModel = modelManager.getModel(sourceTable);
                                                if (tableModel instanceof Table && ((Table) tableModel).isCreateTable()) {
                                                        Table table = (Table) tableModel;
                                                        for (int j = 0; j < table.getColumns().size(); j++) {
                                                                TableColumn tableColumn = table.getColumns().get(j);
                                                                if (column.getExceptColumnList() != null) {
                                                                        boolean except = false;
                                                                        for (TObjectName objectName : column.getExceptColumnList()) {
                                                                                if (DlineageUtil.sameColumnName(objectName.toString(), tableColumn.getName())) {
                                                                                        except = true;
                                                                                        break;
                                                                                }
                                                                        }
                                                                        if (!except && tableColumn.isStruct()) {
                                                                                List<String> names = SQLUtil
                                                                                                .parseNames(tableColumn.getName());
                                                                                for (String name : names) {
                                                                                        for (TObjectName objectName : column
                                                                                                        .getExceptColumnList()) {
                                                                                                if (DlineageUtil.sameColumnName(objectName.toString(), name)) {
                                                                                                        except = true;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                        if (except) {
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                        if (except) {
                                                                                continue;
                                                                        }
                                                                }
                                                                TObjectName columnName = new TObjectName();
                                                                columnName.setString(tableColumn.getName());
                                                                ResultColumn resultColumn = modelFactory.createResultColumn(
                                                                                resultSet, columnName);
                                                                resultColumn.inheritIdentifier(tableColumn);
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                        }
                                                        continue;
                                                } else if (tableModel instanceof ResultSet
                                                                && ((ResultSet) tableModel).isDetermined()) {
                                                        ResultSet table = (ResultSet) tableModel;
                                                        for (int j = 0; j < table.getColumns().size(); j++) {
                                                                ResultColumn tableColumn = table.getColumns().get(j);
                                                                if (column.getExceptColumnList() != null) {
                                                                        boolean except = false;
                                                                        for (TObjectName objectName : column.getExceptColumnList()) {
                                                                                if (DlineageUtil.sameColumnName(objectName.toString(), tableColumn.getName())) {
                                                                                        except = true;
                                                                                        break;
                                                                                }
                                                                        }
                                                                        if (!except && tableColumn.isStruct()) {
                                                                                List<String> names = SQLUtil
                                                                                                .parseNames(tableColumn.getName());
                                                                                for (String name : names) {
                                                                                        for (TObjectName objectName : column
                                                                                                        .getExceptColumnList()) {
                                                                                                if (DlineageUtil.sameColumnName(objectName.toString(), name)) {
                                                                                                        except = true;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                        if (except) {
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                        if (except) {
                                                                                continue;
                                                                        }
                                                                }
                                                                if (tableColumn.getRefColumnName() != null) {
                                                                        TObjectName columnName = new TObjectName();
                                                                        columnName.setString(tableColumn.getRefColumnName());
                                                                        ResultColumn resultColumn = modelFactory.createResultColumn(
                                                                                        resultSet, columnName);
                                                                        resultColumn.inheritIdentifier(tableColumn);
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                } else {
                                                                        TObjectName columnName = new TObjectName();
                                                                        columnName.setString(tableColumn.getName());
                                                                        ResultColumn resultColumn = modelFactory.createResultColumn(
                                                                                        resultSet, columnName);
                                                                        resultColumn.inheritIdentifier(tableColumn);
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                }
                                                        }
                                                        continue;
                                                }
                                                else {
                                                        isDetermined = false;
                                                }
                                        }
                                }
                                        
                                ResultColumn resultColumn = modelFactory.createSelectSetResultColumn(resultSet, column, i);

                                if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                        TResultColumn columnObject = (TResultColumn) resultColumn.getColumnObject();
                                        if (columnObject.getFieldAttr() != null) {
                                                if (DlineageUtil.isStarName((columnObject.getFieldAttr()))) {
                                                        TObjectName fieldAttr = columnObject.getFieldAttr();
                                                        TTable sourceTable = fieldAttr.getSourceTable();
                                                        if (fieldAttr.getTableToken() != null && sourceTable != null) {
                                                                TObjectName[] columns = modelManager.getTableColumns(sourceTable);
                                                                for (int j = 0; j < columns.length; j++) {
                                                                        TObjectName columnName = columns[j];
                                                                        if (columnName == null) {
                                                                                continue;
                                                                        }
                                                                        if (DlineageUtil.isStarName((columnName))) {
                                                                                continue;
                                                                        }
                                                                        resultColumn.bindStarLinkColumn(columnName);
                                                                }

                                                                if (modelManager.getModel(sourceTable) instanceof Table) {
                                                                        Table tableModel = (Table) modelManager.getModel(sourceTable);
                                                                        if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                for (int z = 0; z < tableModel.getColumns().size(); z++) {
                                                                                        if (tableModel.getColumns().get(z).isStarColumn()) {
                                                                                                continue;
                                                                                        }
                                                                                        resultColumn.bindStarLinkColumn(
                                                                                                        tableModel.getColumns().get(z).getColumnObject());
                                                                                }
                                                                        }
                                                                } else if (modelManager.getModel(sourceTable) instanceof QueryTable) {
                                                                        QueryTable tableModel = (QueryTable) modelManager.getModel(sourceTable);
                                                                        if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                for (ResultColumn item : tableModel.getColumns()) {
                                                                                        if (item.hasStarLinkColumn()) {
                                                                                                for (TObjectName starLinkColumn : item.getStarLinkColumnList()) {
                                                                                                        if (DlineageUtil.isStarName((starLinkColumn))) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                                }
                                                                                        } else if (item.getColumnObject() instanceof TObjectName) {
                                                                                                TObjectName starLinkColumn = (TObjectName) item.getColumnObject();
                                                                                                if (DlineageUtil.isStarName((starLinkColumn))) {
                                                                                                        continue;
                                                                                                }
                                                                                                resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                        }
                                                                                }
                                                                        }
                                                                }

                                                        } else {
                                                                TTableList tables = stmt.getTables();
                                                                for (int k = 0; k < tables.size(); k++) {
                                                                        TTable tableElement = tables.getTable(k);
                                                                        TObjectName[] columns = modelManager.getTableColumns(tableElement);
                                                                        for (int j = 0; j < columns.length; j++) {
                                                                                TObjectName columnName = columns[j];
                                                                                if (columnName == null) {
                                                                                        continue;
                                                                                }
                                                                                if (DlineageUtil.isStarName((columnName))) {
                                                                                        if (modelManager.getModel(tableElement) instanceof Table) {
                                                                                                Table tableModel = (Table) modelManager.getModel(tableElement);
                                                                                                if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                                        for (int z = 0; z < tableModel.getColumns().size(); z++) {
                                                                                                                resultColumn.bindStarLinkColumn(
                                                                                                                                tableModel.getColumns().get(z).getColumnObject());
                                                                                                        }
                                                                                                }
                                                                                        } else if (modelManager.getModel(tableElement) instanceof QueryTable) {
                                                                                                QueryTable tableModel = (QueryTable) modelManager
                                                                                                                .getModel(tableElement);
                                                                                                if (tableModel != null && !tableModel.getColumns().isEmpty()) {
                                                                                                        for (ResultColumn item : tableModel.getColumns()) {
                                                                                                                if (item.hasStarLinkColumn()) {
                                                                                                                        for (TObjectName starLinkColumn : item
                                                                                                                                        .getStarLinkColumnList()) {
                                                                                                                                resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                                                        }
                                                                                                                } else if (item.getColumnObject() instanceof TObjectName) {
                                                                                                                        resultColumn.bindStarLinkColumn(
                                                                                                                                        (TObjectName) item.getColumnObject());
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                        continue;
                                                                                }
                                                                                resultColumn.bindStarLinkColumn(columnName);
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                                
                                resultSet.setDetermined(isDetermined);
                        }
                }
        }

        private void analyzeResultColumn(TResultColumn column, EffectType effectType) {
                // A SELECT * star column whose source resolves to a determined result set
                // is bound to a LinkedHashMap of per-column ResultColumns (see
                // ModelFactory.createStarResultColumn), and its data-flow relationships
                // are already created inline during star expansion in analyzeSelectStmt().
                // Re-analyzing the raw "*" here is redundant; skip it. (analyzeDataFlowRelation
                // keeps the same guard as a defensive backstop.)
                if (modelManager.getModel(column) instanceof LinkedHashMap) {
                        return;
                }
                TExpression expression = column.getExpr();
                if (expression.getExpressionType() == EExpressionType.sqlserver_proprietary_column_alias_t) {
                        expression = expression.getRightOperand();
                }

                if (expression.getExpressionType() == EExpressionType.array_t) {
                        if (expression.getExprList() != null) {
                                for (TExpression expr : expression.getExprList()) {
                                        columnsInExpr visitor = new columnsInExpr();
                                        expr.inOrderTraverse(visitor);
                                        List<TObjectName> objectNames = visitor.getObjectNames();

                                        List<TParseTreeNode> functions = visitor.getFunctions();

                                        if (functions != null && !functions.isEmpty()) {
                                                analyzeFunctionDataFlowRelation(column, functions, effectType);
                                        }

                                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                                        if (subquerys != null && !subquerys.isEmpty()) {
                                                analyzeSubqueryDataFlowRelation(column, subquerys, effectType);
                                        }

                                        analyzeDataFlowRelation(column, objectNames, column.getExceptColumnList(), effectType, functions);

                                        List<TParseTreeNode> constants = visitor.getConstants();
                                        Object columnObject = modelManager.getModel(column);
                                        analyzeConstantDataFlowRelation(columnObject, constants, effectType, functions);

                                        analyzeRecordSetRelation(functions, effectType);
                                        // analyzeResultColumnImpact( column, effectType, functions);
                                }
                        }
                        else {
                                List<TParseTreeNode> constants = new ArrayList<TParseTreeNode>();
                                TConstant constant = new TConstant();
                                constant.setString(expression.toString());
                                constants.add(constant);
                                Object columnObject = modelManager.getModel(column);
                                analyzeConstantDataFlowRelation(columnObject, constants, effectType, null);
                        }
                } else {
                        columnsInExpr visitor = new columnsInExpr();
                        expression.inOrderTraverse(visitor);
                        List<TObjectName> objectNames = visitor.getObjectNames();

                        List<TParseTreeNode> functions = visitor.getFunctions();

                        if (functions != null && !functions.isEmpty()) {
                                analyzeFunctionDataFlowRelation(column, functions, effectType);
                        }

                        List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                        if (subquerys != null && !subquerys.isEmpty()) {
                                analyzeSubqueryDataFlowRelation(column, subquerys, effectType);
                        }

                        analyzeDataFlowRelation(column, objectNames, column.getExceptColumnList(), effectType, functions);

                        List<TParseTreeNode> constants = visitor.getConstants();
                        Object columnObject = modelManager.getModel(column);
                        analyzeConstantDataFlowRelation(columnObject, constants, effectType, functions);

                        analyzeRecordSetRelation(functions, effectType);
                        // analyzeResultColumnImpact( column, effectType, functions);
                }
        }
        
        
        /**
         * A VALUES derived table that parses as a subquery, e.g. PostgreSQL, Athena and Databricks
         * {@code LEFT JOIN (VALUES (0, 'G'), (1, 'I')) AS r(rank, type)}: its select has a value clause and no
         * result column list, so it gets no result set model. Each row feeds the alias columns by position, the
         * same way the {@link ETableSource#rowList} branch handles SQL Server and Snowflake VALUES tables
         * (Mantis 4802). Without an alias column list the columns take the vendor's default names,
         * {@link TValueClause#defaultColumnName}: PostgreSQL column1, column2, ... (Mantis 4823).
         */
        private void analyzeValuesDerivedTable(QueryTable queryTable, TValueClause valueClause) {
                List<TResultColumnList> rows = valueClause.getRows();
                if (rows == null || rows.isEmpty()) {
                        return;
                }
                if (queryTable.getColumns().isEmpty() && rows.get(0) != null) {
                        for (int j = 1; j <= rows.get(0).size(); j++) {
                                String name = TValueClause.defaultColumnName(option.getVendor(), j);
                                if (name == null) {
                                        break;
                                }
                                TObjectName columnName = new TObjectName();
                                columnName.setString(name);
                                modelFactory.createResultColumn(queryTable, columnName, true);
                        }
                }
                if (queryTable.getColumns().isEmpty()) {
                        return;
                }
                for (TResultColumnList row : rows) {
                        if (row == null) {
                                continue;
                        }
                        for (int j = 0; j < row.size() && j < queryTable.getColumns().size(); j++) {
                                analyzeValueColumn(queryTable.getColumns().get(j), row.getResultColumn(j), EffectType.select);
                        }
                }
        }

        /**
         * Mantis 5010: the columns of a CTE defined by VALUES, as UPDATE ... FROM reads it, or a query (Mantis 5017).
         * Position j of every row feeds the column the list names at j or, past the list, the column of the vendor's
         * default name for j ({@link TValueClause#defaultColumnName}; PostgreSQL keeps those names after a shorter list). A
         * column a reference made earlier is found by its name, not by its place among the CTE's columns, which is the
         * order of the reads. The relations into the columns belong to {@code process}, as the UPDATE's other CTE relations
         * do; a query passes null.
         */
        private void analyzeValuesCte(QueryTable queryTable, TValueClause valueClause, TObjectNameList cteColumns,
                        Process process) {
                List<TResultColumnList> rows = valueClause.getRows();
                if (rows == null || rows.isEmpty() || rows.get(0) == null) {
                        return;
                }
                List<ResultColumn> positions = new ArrayList<ResultColumn>();
                for (int j = 0; j < rows.get(0).size(); j++) {
                        TObjectName name = null;
                        if (cteColumns != null && j < cteColumns.size()) {
                                name = cteColumns.getObjectName(j);
                        } else if (TValueClause.defaultColumnName(option.getVendor(), j + 1) != null) {
                                name = new TObjectName();
                                name.setString(TValueClause.defaultColumnName(option.getVendor(), j + 1));
                        }
                        ResultColumn column = name == null ? null : matchResultColumn(queryTable.getColumns(), name);
                        if (name != null && column == null) {
                                column = modelFactory.createResultColumn(queryTable, name, true);
                        }
                        positions.add(column);
                }
                int relationsBefore = modelManager.getRelations().length;
                for (TResultColumnList row : rows) {
                        for (int j = 0; row != null && j < row.size() && j < positions.size(); j++) {
                                if (positions.get(j) != null) {
                                        analyzeValueColumn(positions.get(j), row.getResultColumn(j), EffectType.select);
                                }
                        }
                }
                setProcessOfRelationsInto(relationsBefore, positions, process);
        }

        /**
         * Mantis 5015: SET p = (VALUES (...)) and SET (p, q) = (VALUES (...)) assign from a VALUES list, which has no result
         * set model: item {@code position} of each row feeds {@code tableColumn}, as the rows of a VALUES derived table feed
         * its columns, in the UPDATE's process. Reading the model threw NullPointerException.
         */
        private void analyzeUpdateSetValues(TableColumn tableColumn, TValueClause valueClause, int position,
                        Process process) {
                List<TResultColumnList> rows = valueClause.getRows();
                if (rows == null) {
                        return;
                }
                int relationsBefore = modelManager.getRelations().length;
                for (TResultColumnList row : rows) {
                        if (row != null && position < row.size()) {
                                analyzeValueColumn(tableColumn, row.getResultColumn(position), EffectType.update);
                        }
                }
                setProcessOfRelationsInto(relationsBefore, Collections.singletonList(tableColumn), process);
        }

        /** Gives {@code process} to the relations made since {@code relationsBefore} into one of {@code targets} without one. */
        private void setProcessOfRelationsInto(int relationsBefore, List<?> targets, Process process) {
                Relationship[] relations = modelManager.getRelations();
                for (int i = relationsBefore; i < relations.length; i++) {
                        if (!(relations[i] instanceof AbstractRelationship) || relations[i].getTarget() == null
                                        || ((AbstractRelationship) relations[i]).getProcess() != null) {
                                continue;
                        }
                        Object target = relations[i].getTarget().getElement();
                        for (Object column : targets) {
                                if (column != null && column == target) {
                                        ((AbstractRelationship) relations[i]).setProcess(process);
                                        break;
                                }
                        }
                }
        }

        private void analyzeValueColumn(Object object, TResultColumn column, EffectType effectType) {
                TExpression expression = column.getExpr();
                if (expression.getExpressionType() == EExpressionType.sqlserver_proprietary_column_alias_t) {
                        expression = expression.getRightOperand();
                }

                if (expression.getExpressionType() == EExpressionType.array_t) {
                        if (expression.getExprList() != null) {
                                for (TExpression expr : expression.getExprList()) {
                                        analyzeValueExpression(object, expr, column, effectType);
                                }
                        }
                        else {
                                List<TParseTreeNode> constants = new ArrayList<TParseTreeNode>();
                                TConstant constant = new TConstant();
                                constant.setString(expression.toString());
                                constants.add(constant);
                                Object columnObject = modelManager.getModel(column);
                                analyzeConstantDataFlowRelation(object, constants, effectType, null);
                        }
                } else {
                        analyzeValueExpression(object, expression, column, effectType);
                }
        }

        /** The inputs of one value of a VALUES row, or of one element of an ARRAY in it, into {@code object}. */
        private void analyzeValueExpression(Object object, TExpression expression, TResultColumn column, EffectType effectType) {
                columnsInExpr visitor = new columnsInExpr();
                expression.inOrderTraverse(visitor);
                // A function in a VALUES row, e.g. (VALUES (COALESCE((SELECT x FROM t), 0))) AS r(a), gives the column its
                // value as in a SELECT list: its arguments, a scalar subquery or a column, feed it (Mantis 4824)
                List<TParseTreeNode> functions = visitor.getFunctions();
                if (functions != null && !functions.isEmpty()) {
                        analyzeFunctionDataFlowRelation(object, functions, effectType);
                }
                // A scalar subquery in a VALUES row, e.g. (VALUES ((SELECT max(p) FROM t), 'G')) AS r(rank, type),
                // is the value of that column: link its result (Mantis 4802)
                List<TSelectSqlStatement> subquerys = visitor.getSubquerys();
                if (subquerys != null && !subquerys.isEmpty()) {
                        analyzeSubqueryDataFlowRelation(object, subquerys, effectType);
                }
                List<TObjectName> objectNames = visitor.getObjectNames();
                analyzeDataFlowRelation(object, objectNames, column.getExceptColumnList(), effectType, null, null);
                List<TParseTreeNode> constants = visitor.getConstants();
                analyzeConstantDataFlowRelation(object, constants, effectType, null);
        }

        private void analyzeTableColumn(TableColumn tableColumn, TFunctionCall functionCall, EffectType effectType) {
                // SQL-LR: a nested analysis never inherits the reference of the loop that called it
                SqllrObservations sqllr = modelManager.getSqllrObservations();
                int sqllrBarrier = sqllr == null ? -1 : sqllr.openFrame();
                try {
                        analyzeTableColumnInSqllrBarrier(tableColumn, functionCall, effectType);
                } finally {
                        if (sqllr != null) {
                                sqllr.closeFrame(sqllrBarrier);
                        }
                }
        }

        private void analyzeTableColumnInSqllrBarrier(TableColumn tableColumn, TFunctionCall functionCall, EffectType effectType) {
                // ClickHouse external table functions are modelled as source TABLES
                // (modelClickhouseExternalTableFunction); running the generic
                // function-argument analysis on top fabricates argument-named columns
                // on that table (remote('h', mydb, mytable) invented a column "mydb")
                // and re-attaches the generic function node the modelling replaced.
                if (option.getVendor() == EDbVendor.dbvclickhouse && functionCall != null
                                && functionCall.getFunctionName() != null) {
                        String rawName = functionCall.getFunctionName().toString();
                        if (isClickhouseTableFunction(rawName, "remote")
                                        || isClickhouseTableFunction(rawName, "remoteSecure")
                                        || isClickhouseTableFunction(rawName, "file")
                                        || isClickhouseTableFunction(rawName, "s3")
                                        || isClickhouseTableFunction(rawName, "url")
                                        || isClickhouseTableFunction(rawName, "hdfs")
                                        || isClickhouseTableFunction(rawName, "fileCluster")
                                        || isClickhouseTableFunction(rawName, "s3Cluster")
                                        || isClickhouseTableFunction(rawName, "urlCluster")
                                        || isClickhouseTableFunction(rawName, "hdfsCluster")
                                        || isClickhouseTableFunction(rawName, "azureBlobStorage")
                                        || isClickhouseTableFunction(rawName, "azureBlobStorageCluster")) {
                                return;
                        }
                }
                List<TParseTreeNode> functions = new ArrayList<TParseTreeNode>();
                functions.add(functionCall);

                if (functions != null && !functions.isEmpty()) {
                        analyzeFunctionDataFlowRelation(tableColumn, functions, effectType);
                }

                analyzeRecordSetRelation(functions, effectType);
        }

        private void analyzeRecordSetRelation(List<TParseTreeNode> functions, EffectType effectType) {
                analyzeRecordSetRelation(functions, effectType, false);
        }

        /**
         * The row influence of each aggregate in {@code functions}: the GROUP BY keys, the HAVING clause and the rows of
         * the statement. {@code inHaving}: the aggregates are those of the HAVING clause itself, which therefore is not
         * one of their inputs.
         */
        private void analyzeRecordSetRelation(List<TParseTreeNode> functions, EffectType effectType, boolean inHaving) {
                if (functions == null || functions.size() == 0)
                        return;

                List<TFunctionCall> aggregateFunctions = new ArrayList<TFunctionCall>();
                for (TParseTreeNode function : functions) {
                        if (function instanceof TFunctionCall && isAggregateFunction((TFunctionCall) function)) {
                                aggregateFunctions.add((TFunctionCall) function);
                        }
                }

                if (aggregateFunctions.size() == 0)
                        return;

                for (int i = 0; i < aggregateFunctions.size(); i++) {
                        TFunctionCall function = aggregateFunctions.get(i);

                        TCustomSqlStatement stmt = stmtStack.peek();
                        if (stmt instanceof TSelectSqlStatement) {
                                TSelectSqlStatement select = (TSelectSqlStatement) stmt;
                                if (select.getGroupByClause() != null) {
                                        if (select.getGroupByClause().isAllModifier()) {
                                                // GROUP BY ALL: implicit grouping columns are the
                                                // non-aggregate expressions in the SELECT list.
                                                TResultColumnList resultColumns = select.getResultColumnList();
                                                if (resultColumns != null) {
                                                        for (int j = 0; j < resultColumns.size(); j++) {
                                                                TResultColumn column = resultColumns.getResultColumn(j);
                                                                TExpression expr = column.getExpr();
                                                                if (expr == null)
                                                                        continue;
                                                                columnsInExpr aggVisitor = new columnsInExpr();
                                                                expr.inOrderTraverse(aggVisitor);
                                                                boolean containsAggregate = false;
                                                                for (TParseTreeNode funcNode : aggVisitor.getFunctions()) {
                                                                        if (funcNode instanceof TFunctionCall
                                                                                        && isAggregateFunction((TFunctionCall) funcNode)) {
                                                                                containsAggregate = true;
                                                                                break;
                                                                        }
                                                                }
                                                                if (!containsAggregate) {
                                                                        analyzeAggregate(function, expr);
                                                                }
                                                        }
                                                }
                                        } else {
                                                TGroupByItemList groupByList = select.getGroupByClause().getItems();
                                                for (int j = 0; j < groupByList.size(); j++) {
                                                        TGroupByItem groupBy = groupByList.getGroupByItem(j);
                                                        TExpression expr = groupBy.getExpr();
                                                        analyzeAggregate(function, expr);
                                                }
                                        }

                                        if (!inHaving && select.getGroupByClause().getHavingClause() != null) {
                                                analyzeAggregate(function, select.getGroupByClause().getHavingClause());
                                        }
                                        // if ("COUNT".equalsIgnoreCase(function.getFunctionName().toString()))
                                        {
                                                analyzeAggregate(function, null);
                                        }
                                } else {
                                        analyzeAggregate(function, null);
                                }
                        }
                }
        }

        private void analyzeDataFlowRelation(TParseTreeNode gspObject, List<TObjectName> objectNames,
                        TObjectNameList exceptColumnList, EffectType effectType, List<TParseTreeNode> functions) {
                Object columnObject = modelManager.getModel(gspObject);
                analyzeDataFlowRelation(columnObject, objectNames, exceptColumnList, effectType, functions, null);
        }

        private DataFlowRelationship analyzeDataFlowRelation(Object modelObject, List<TObjectName> objectNames, EffectType effectType,
                        List<TParseTreeNode> functions) {
                return analyzeDataFlowRelation(modelObject, objectNames, null, effectType, functions, null);
        }
        
        /**
         * Whether a column reference that no table exposes names this result column of its own SELECT block, by name.
         * Never for SAP IQ and SQL Anywhere: they take only the alias the resolvers bound the reference to, before any
         * table lookup ({@link #getBoundAliasColumn}); matching by name would also take a variable, a {@code @@} global or
         * the target of a {@code SELECT @v = x} assignment for an alias (Mantis 4752).
         */
        private boolean isAliasReference(TObjectName columnName, ResultColumn resultColumn) {
                if (TSQLEnv.isAliasOccludingColumn(option.getVendor())) {
                        return false;
                }
                return DlineageUtil.sameColumnName(columnName, resultColumn.getName());
        }

        /**
         * SAP IQ and SQL Anywhere: the result column of the SELECT-list alias the resolvers bound this unqualified name to
         * ({@link TObjectName#getSourceColumn()}, from {@code TResultColumnList.findLateralAliasDefinition} for an alias
         * of its own SELECT block, {@code TSelectSqlStatement.findEnclosingAliasDefinition} for one of an enclosing
         * block), or null. The alias occludes a column of the same name, so it is taken before any table lookup
         * (Mantis 4752). Likewise for a HAVING name in the dialects of {@link TSQLEnv#isAliasVisibleInHaving}, which the
         * resolvers bind to the alias only when no table column of that name is proven.
         */
        private ResultColumn getBoundAliasColumn(TObjectName columnName, Object modelObject) {
                if (!TSQLEnv.isAliasOccludingColumn(option.getVendor())
                                && !(columnName.getLocation() == ESqlClause.having
                                                && TSQLEnv.isAliasVisibleInHaving(option.getVendor(), columnName.getGsqlparser()))) {
                        return null;
                }
                TResultColumn alias = columnName.getSourceColumn();
                if (alias == null || columnName.getSourceTable() != null || !alias.isMatchedUsingAlias(columnName)) {
                        return null;
                }
                Object model = modelManager.getModel(alias);
                if (!(model instanceof ResultColumn) || model.equals(modelObject)) {
                        return null;
                }
                return (ResultColumn) model;
        }

        private DataFlowRelationship analyzeDataFlowRelation(Object modelObject, List<TObjectName> objectNames, EffectType effectType,
                        List<TParseTreeNode> functions, Process process) {
                return analyzeDataFlowRelation(modelObject, objectNames, null, effectType, functions, process);
        }

        private DataFlowRelationship analyzeDataFlowRelation(Object modelObject, List<TObjectName> objectNames,
                        TObjectNameList exceptColumnList, EffectType effectType, List<TParseTreeNode> functions, Process process) {
                return analyzeDataFlowRelation(modelObject, objectNames, exceptColumnList, effectType, functions, process, null);
        }
        
        private DataFlowRelationship analyzeDataFlowRelation(Object modelObject, List<TObjectName> objectNames,
                        TObjectNameList exceptColumnList, EffectType effectType, List<TParseTreeNode> functions, Process process, Integer valueIndex) {
                // SQL-LR: a nested analysis never inherits the reference of the loop that called it
                SqllrObservations sqllr = modelManager.getSqllrObservations();
                int sqllrBarrier = sqllr == null ? -1 : sqllr.openFrame();
                try {
                        return analyzeDataFlowRelationInSqllrBarrier(modelObject, objectNames, exceptColumnList, effectType, functions, process,
                                        valueIndex);
                } finally {
                        if (sqllr != null) {
                                sqllr.closeFrame(sqllrBarrier);
                        }
                }
        }

        private DataFlowRelationship analyzeDataFlowRelationInSqllrBarrier(Object modelObject, List<TObjectName> objectNames,
                        TObjectNameList exceptColumnList, EffectType effectType, List<TParseTreeNode> functions, Process process, Integer valueIndex) {
                if (objectNames == null || objectNames.size() == 0)
                        return null;

                // Reject model objects this method cannot turn into a relationship BEFORE
                // creating one, since createDataFlowRelation() registers the relation
                // globally and an early return afterwards would leak an empty relation.
                //
                // - LinkedHashMap: a SELECT * star column whose source resolves to a
                //   determined result set is expanded into per-column ResultColumns held
                //   in a LinkedHashMap by ModelFactory.createStarResultColumn(), with its
                //   data-flow relationships created inline during star expansion in
                //   analyzeSelectStmt(). Re-analyzing the raw "*" here is a no-op.
                // - null: modelManager.getModel() found no binding for the gsp object.
                if (modelObject == null || modelObject instanceof LinkedHashMap) {
                        return null;
                }
                // Lineage is best-effort: an unexpected model type should not abort the
                // whole statement's lineage (this used to throw UnsupportedOperationException).
                // Log it for diagnosis and skip just this column instead.
                if (!(modelObject instanceof ResultColumn) && !(modelObject instanceof TableColumn)) {
                        logger.warn("analyzeDataFlowRelation: unhandled model type "
                                        + modelObject.getClass().getName() + ", effectType=" + effectType);
                        return null;
                }

                boolean isStar = false;
                boolean showStar = false;

                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(effectType);
                relation.setProcess(process);

                if (functions != null && !functions.isEmpty()) {
                        relation.setFunction(getFunctionName(functions.get(0)));
                }

                int columnIndex = -1;

                boolean isOut = false;

                if (modelObject instanceof ResultColumn) {
                        relation.setTarget(new ResultColumnRelationshipElement((ResultColumn) modelObject));

                        if (((ResultColumn) modelObject).isStarColumn()) {
                                isStar = true;
                                showStar = ((ResultColumn) modelObject).isShowStar();
                        }

                        if (((ResultColumn) modelObject).getResultSet() != null) {
                                columnIndex = ((ResultColumn) modelObject).getResultSet().getColumns().indexOf(modelObject);
                        }
                } else if (modelObject instanceof TableColumn) {
                        Table table  = ((TableColumn) modelObject).getTable();
                        if(table.getSubType() == SubType.out && isNotInProcedure(table)){
                                isOut = true;
                                relation.addSource(new TableColumnRelationshipElement((TableColumn) modelObject));
                        }
                        else {
                                relation.setTarget(new TableColumnRelationshipElement((TableColumn) modelObject));
                        }

                        if (((TableColumn) modelObject).isStarColumn()) {
                                isStar = true;
                        }

                        if (((TableColumn) modelObject).getTable() != null) {
                                columnIndex = ((TableColumn) modelObject).getTable().getColumns().indexOf(modelObject);
                        }
                }
                // No trailing else: modelObject is guaranteed to be a ResultColumn or
                // TableColumn here (validated and logged above before relation creation).

                SqllrObservations sqllrRefs = modelManager.getSqllrObservations();
                int sqllrFrame = sqllrRefs == null ? -1 : sqllrRefs.openFrame(modelObject);
                try { // SQL-LR: each element added in this loop is recorded with the reference of its iteration
                for (int i = 0; i < objectNames.size(); i++) {
                        TObjectName columnName = objectNames.get(i);
                        if (sqllrRefs != null) {
                                sqllrRefs.reference(sqllrFrame, columnName);
                        }
                        ResultColumn boundAlias = getBoundAliasColumn(columnName, modelObject);
                        if (boundAlias != null) {
                                relation.addSource(new ResultColumnRelationshipElement(boundAlias));
                                continue;
                        }
                        if (columnName.toString().indexOf(".") == -1 && isConstant(columnName)) {
                                boolean isConstant = true;
                                if (columnName.getSourceTable() != null) {
                                        Table tableModel = modelManager.getTableByName(
                                                        DlineageUtil.getTableIdentityKey(columnName.getSourceTable().getTableName().toString()));
                                        if (tableModel != null && tableModel.getColumns() != null) {
                                                for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                        if (sameTableColumn(columnName, tableModel.getColumns().get(j))) {
                                                                isConstant = false;
                                                                break;
                                                        }
                                                }
                                        }
                                }

                                if (isConstant) {
                                        if (option.isShowConstantTable()) {
                                                Table constantTable = modelFactory.createConstantsTable(stmtStack.peek());
                                                TableColumn tableColumn = modelFactory.createTableColumn(constantTable, columnName, false);
                                                if(tableColumn!=null) {
                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                }
                                        }
                                        continue;
                                }
                        }
                        if (columnName.getDbObjectType() == EDbObjectType.variable) {
                                boolean find = false;
                                List<String> segments = SQLUtil.parseNames(columnName.toString());
                                if (segments.size() == 1) {
                                        Table variable = modelManager.visibleLocal(columnName.toString(), LocalSymbolKey.Kind.VARIABLE);
                                        if (variable != null && !variable.getColumns().isEmpty()) {
                                                TableColumn columnModel = variable.getColumns().get(0);
                                                TableColumn matchColumn = matchColumn(variable.getColumns(), columnName);
                                                if(matchColumn!=null){
                                                        columnModel = matchColumn;
                                                } else if (variable.getColumns().size() > 1 && variable instanceof Variable) {
                                                        // A bare reference to a field-expanded record is the
                                                        // WHOLE record (#695): bind its star, never an
                                                        // arbitrary first field — citing one field asserts
                                                        // the value ignores the others.
                                                        columnModel = compositeBindingColumn((Variable) variable);
                                                }
                                                if(isOut){
                                                        relation.setTarget(new TableColumnRelationshipElement(columnModel));
                                                }
                                                else {
                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                }
                                                find = true;
                                        } else {
                                                if (columnName.toString().matches("\\$\\d+")) {
                                                        TCustomSqlStatement stmt = stmtStack.peek();
                                                        Procedure procedure = getEnclosingProcedure(stmt);
                                                        if(procedure!=null) {
                                                                Variable cursorVariable = modelFactory.createReferencedVariable(procedure.getArguments().get(Integer.valueOf(columnName.toString().replace("$", "")) - 1).getName(), true);
                                                                if (isOut) {
                                                                        relation.setTarget(new TableColumnRelationshipElement(cursorVariable.getColumns().get(0)));
                                                                } else {
                                                                        relation.addSource(new TableColumnRelationshipElement(cursorVariable.getColumns().get(0)));
                                                                }
                                                        }
                                                } else {
                                                        Variable cursorVariable = modelFactory.createReferencedVariable(columnName);
                                                        cursorVariable.setCreateTable(true);
                                                        cursorVariable.setSubType(SubType.record);
                                                        TableColumn variableProperty = null;
                                                        if(cursorVariable.getColumns() == null || cursorVariable.getColumns().isEmpty()) {
                                variableProperty = modelFactory.createTableColumn(cursorVariable, columnName,
                                        true);
                            }
                                                        else{
                                                                variableProperty = compositeBindingColumn(cursorVariable);
                                                        }
                                                        if (isOut) {
                                                                relation.setTarget(new TableColumnRelationshipElement(variableProperty));
                                                        } else {
                                                                relation.addSource(new TableColumnRelationshipElement(variableProperty));
                                                        }
                                                }
                                                find = true;
                                        }
                                } else if (option.getVendor() == EDbVendor.dbvoracle && columnName.getTableToken()!=null) {
                                        Variable cursorVariable = modelFactory
                                                        .createReferencedVariable(columnName.getTableToken().toString(), true);

                                        TObjectName variableColumnName = new TObjectName();
                                        variableColumnName.setString(segments.get(segments.size() - 1));

                                        if (cursorVariable.getColumns() != null) {
                                                for (int j = 0; j < cursorVariable.getColumns().size(); j++) {
                                                        if (DlineageUtil.sameColumnName(variableColumnName, cursorVariable.getColumns().get(j).getColumnObject())) {
                                                                TableColumn columnModel = cursorVariable.getColumns().get(j);
                                                                if (isOut) {
                                                                        relation.setTarget(new TableColumnRelationshipElement(columnModel));
                                                                } else {
                                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                }
                                                                find = true;
                                                        }
                                                }
                                        }

                                        if (!find) {
                                                TableColumn variableColumn = new TableColumn(cursorVariable, variableColumnName);
                                                cursorVariable.addColumn(variableColumn);
                                                if (isOut) {
                                                        relation.setTarget(new TableColumnRelationshipElement(variableColumn));
                                                } else {
                                                        relation.addSource(new TableColumnRelationshipElement(variableColumn));
                                                }
                                        }
                                } else {
                                        Table variable = modelManager.visibleLocal(segments.get(segments.size() - 2),
                                                        LocalSymbolKey.Kind.VARIABLE);
                                        if (variable != null) {
                                                for (int j = 0; j < variable.getColumns().size(); j++) {
                                                        if (DlineageUtil.sameColumnName(columnName, variable.getColumns().get(j).getColumnObject())) {
                                                                TableColumn columnModel = variable.getColumns().get(j);
                                                                if (isOut) {
                                                                        relation.setTarget(new TableColumnRelationshipElement(columnModel));
                                                                } else {
                                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                }
                                                                find = true;
                                                        }
                                                }
                                        }
                                }
                                if (!find) {
                                        TCustomSqlStatement stmt = stmtStack.peek();
                                        if (getProcedureParentName(stmt) != null) {
                                                Procedure procedure = getEnclosingProcedure(stmt);
                                                if (procedure != null && procedure.getArguments() != null) {
                                                        for (Argument argument : procedure.getArguments()) {
                                                                if (DlineageUtil.sameName(ESQLDataObjectType.dotParameter, argument.getName(),
                                                                                columnName.toString())) {
                                                                        relation.addSource(new ArgumentRelationshipElement(argument));
                                                                }
                                                        }
                                                }
                                        }
                                }
                                continue;
                        }
                        
                        // Handle sequence pseudocolumn syntax (sequence.NEXTVAL or sequence.CURRVAL)
                        // Used by Oracle, Snowflake, and accepted by other vendors for compatibility
                        if(("NEXTVAL".equalsIgnoreCase(columnName.getColumnNameOnly()) || "CURRVAL".equalsIgnoreCase(columnName.getColumnNameOnly()))){
                                List<String> segments = SQLUtil.parseNames(columnName.toString());
                                if (segments.size() > 1) {
                                        segments.remove(segments.size()-1);
                                        Table table = modelFactory.createTableByName(SQLUtil.mergeSegments(segments, 0), true);
                                        table.setSequence(true);
                                        TableColumn seqCursor = modelFactory.createTableColumn(table, columnName, true);
                                        relation.addSource(new TableColumnRelationshipElement(seqCursor));
                                        continue;
                                }
                        }

                        {
                                if (columnName.getSourceTable() != null) {

                                }
                                else {
                                        Table variable = modelManager.visibleLocal(columnName.toString(), LocalSymbolKey.Kind.VARIABLE);
                                        if (variable == null) {
                                                // cur.col: the qualifier names a cursor.
                                                variable = modelManager.visibleLocal(columnName.getTableString(), LocalSymbolKey.Kind.CURSOR);
                                                if (variable != null && variable.isCursor()) {
                                                        TableColumn variableColumn = modelFactory.createInsertTableColumn(variable, columnName);
                                                        if (variableColumn != null) {
                                                                if(isOut){
                                                                        relation.setTarget(new TableColumnRelationshipElement(variableColumn));
                                                                }
                                                                else {
                                                                        relation.addSource(new TableColumnRelationshipElement(variableColumn));
                                                                }
                                                        } else {
                                                                TableColumn wholeValue = variable instanceof Variable
                                                                                ? compositeBindingColumn((Variable) variable)
                                                                                : variable.getColumns().get(0);
                                                                if(isOut){
                                                                        relation.setTarget(new TableColumnRelationshipElement(wholeValue));
                                                                }
                                                                else {
                                                                        relation.addSource(new TableColumnRelationshipElement(wholeValue));
                                                                }
                                                        }
                                                        continue;
                                                }
                                        } else if (variable.isVariable() || variable.isCursor()) {
                                                TableColumn columnModel = variable.getColumns().get(0);
                                                if (valueIndex != null) {
                                                        if(isOut){
                                                                relation.setTarget(new TableColumnRelationshipElement(columnModel, valueIndex));
                                                        }
                                                        else {
                                                                relation.addSource(new TableColumnRelationshipElement(columnModel, valueIndex));
                                                        }
                                                } else {
                                                        if(isOut){
                                                                relation.setTarget(new TableColumnRelationshipElement(columnModel));
                                                        }
                                                        else {
                                                                relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                        }
                                                }
                                                continue;
                                        }
                                }
                        }
                        
                        if (columnName.getColumnNameOnly().startsWith("@")
                                        && (option.getVendor() == EDbVendor.dbvmssql || option.getVendor() == EDbVendor.dbvazuresql)) {
                                continue;
                        }

                        if (columnName.getColumnNameOnly().startsWith(":")
                                        && (option.getVendor() == EDbVendor.dbvhana || option.getVendor() == EDbVendor.dbvteradata)) {
                                // HANA / Teradata :var in SQL reads the routine's variable var.
                                Table variable = modelManager.visibleLocal(columnName.getColumnNameOnly().replace(":", ""),
                                                LocalSymbolKey.Kind.VARIABLE);
                                if (variable != null) {
                                        for (int j = 0; j < variable.getColumns().size(); j++) {
                                                if (DlineageUtil.sameName(ESQLDataObjectType.dotColumn,
                                                                DlineageUtil.rawColumnName(columnName).replace(":", ""),
                                                                DlineageUtil.rawColumnName(variable.getColumns().get(j).getColumnObject()))) {
                                                        TableColumn columnModel = variable.getColumns().get(j);
                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                }
                                        }
                                }
                                continue;
                        }

                        boolean linkedFirstTable = false;
                        
                        TCustomSqlStatement stmt = stmtStack.peek();
                        TTableList tableList = stmt.tables;
                        if ((tableList == null || tableList.size() == 0) && (hiveFromTables != null && hiveFromTables.size() > 0)) {
                                tableList = hiveFromTables;
                        }

                        List<TTable> tables = new ArrayList<TTable>();
                        {
                                TTable table = columnName.getSourceTable();

                                // 针对CursorVariable特殊处理
                                if (columnName.getTableToken() != null) {

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

                                        if (tableModel == null) {
                                                // A qualifier no FROM item declares: a record, cursor or trigger correlation visible from here
                                                // first, as PL/SQL scoping does; else a table of that name.
                                                tableModel = modelManager.resolveMixedRelation(columnName.getTableToken().toString(),
                                                                modelManager.getTableByName(DlineageUtil.getTableIdentityKey(columnName.getTableToken().toString())),
                                                                true);
                                        }

                                        if (tableModel != null) {

                                                if (table == null) {
                                                        table = tableModel.getTableObject();
                                                }

                                                if (tableModel.isVariable()) {
                                                        if (!isStar && DlineageUtil.isStarName((columnName))) {
                                                                TObjectName[] columns = modelManager.getTableColumns(table);
                                                                for (int j = 0; j < columns.length; j++) {
                                                                        TObjectName objectName = columns[j];
                                                                        if (objectName == null || DlineageUtil.isStarName((objectName))) {
                                                                                continue;
                                                                        }
                                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel, objectName,
                                                                                        false);
                                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                }
                                                        } else {
                                                                if (DlineageUtil.isStarName((columnName)) && !tableModel.getColumns().isEmpty()) {

                                                                        for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                                                TableColumn columnModel = tableModel.getColumns().get(j);
                                                                                if (exceptColumnList != null) {
                                                                                        boolean flag = false;
                                                                                        for (TObjectName objectName : exceptColumnList) {
                                                                                                if (DlineageUtil.sameColumnName(objectName, columnModel.getColumnObject())) {
                                                                                                        flag = true;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                        if (flag) {
                                                                                                continue;
                                                                                        }
                                                                                }
                                                                                relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                        }

                                                                        if (isStar && showStar) {
                                                                                TableColumn columnModel = modelFactory.createTableColumn(tableModel, columnName,
                                                                                                false);
                                                                                if (columnModel == null) {
                                                                                        if (tableModel.isCreateTable()) {
                                                                                                for (TableColumn tableColumn : tableModel.getColumns()) {
                                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                        relation.setShowStarRelation(true);
                                                                                                }
                                                                                        }
                                                                                } else {
                                                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                                        relation.setShowStarRelation(true);
                                                                                }
                                                                        }
                                                                } else {
                                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel, columnName,
                                                                                        false);
                                                                        
                                                                        if(columnModel == null && containStarColumn(tableModel.getColumns())){
                                                                                columnModel = getStarColumn(tableModel.getColumns());
                                                                                if (columnModel != null && tableModel.getSubType() == SubType.record_type) {
                                                                                        if(!DlineageUtil.isStarName((columnName))){
                                                                                                columnModel.bindStarLinkColumn(columnName);
                                                                                        }
                                                                                }
                                                                        }
                                                                        
                                                                        if (columnModel == null) {
                                                                                continue;
                                                                        }
                                                                        if (columnModel.hasStarLinkColumn()) {
                                                                                relation.addSource(new TableColumnRelationshipElement(columnModel,
                                                                                                columnModel.starLinkIndexOf(columnName)));
                                                                        } else {
                                                                                if (isOut) {
                                                                                        relation.setTarget(new TableColumnRelationshipElement(columnModel));
                                                                                } else {
                                                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                                }
                                                                        }
                                                                        if (columnName.getSourceTable() != null
                                                                                        && columnName.getSourceTable().getTableType() == ETableSource.function) {
                                                                                analyzeTableColumn(columnModel, columnName.getSourceTable().getFuncCall(),
                                                                                                effectType);
                                                                        }
                                                                }
                                                        }
                                                        continue;
                                                }
                                        }
                                }

                                if (table == null) {
                                        table = modelManager.getTable(stmt, columnName);
                                }

                                if (table == null) {
                                        if (columnName.getTableToken() != null || !DlineageUtil.isStarName((columnName))) {
                                                table = columnName.getSourceTable();
                                        }
                                        
                                        if (table == null && !SQLUtil.isEmpty(columnName.getTableString())) {
                                                table = modelManager.getTableFromColumn(columnName);
                                        }
                                }

                                if (table == null) {
                                        if (tableList != null) {
                                                for (int j = 0; j < tableList.size(); j++) {
                                                        if (table != null)
                                                                break;

                                                        TTable tTable = tableList.getTable(j);
                                                        if (tTable.getTableType().name().startsWith("open")) {
                                                                continue;
                                                        }

                                                        if (getTableLinkedColumns(tTable) != null && getTableLinkedColumns(tTable).size() > 0) {
                                                                for (int z = 0; z < getTableLinkedColumns(tTable).size(); z++) {
                                                                        TObjectName refer = getTableLinkedColumns(tTable).getObjectName(z);
                                                                        if (DlineageUtil.isStarName((refer)))
                                                                                continue;
                                                                        // For BigQuery struct field access, match base column name from FieldPath
                                                                        String structFullName = getStructFieldFullName(columnName);
                                                                        if (structFullName != null) {
                                                                                String baseName = getStructFieldBaseName(columnName);
                                                                                if (baseName != null && DlineageUtil.sameColumnName(refer, baseName)) {
                                                                                        table = tTable;
                                                                                        break;
                                                                                }
                                                                        }
                                                                        if (DlineageUtil.sameColumnName(refer, columnName)) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                }
                                                        }

                                                        if (tTable.getLinkTable() != null) {
                                                                tTable = tTable.getLinkTable();
                                                                for (int z = 0; z < getTableLinkedColumns(tTable).size(); z++) {
                                                                        TObjectName refer = getTableLinkedColumns(tTable).getObjectName(z);
                                                                        if (DlineageUtil.isStarName((refer)))
                                                                                continue;
                                                                        if (DlineageUtil.sameColumnName(refer, columnName)) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                }
                                                        }

                                                        if (table != null)
                                                                break;

                                                        if (columnName.getTableToken() != null && (SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotTable,
                                                                        columnName.getTableToken().getAstext(), tTable.getName())
                                                                        || SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotTable, columnName.getTableToken().getAstext(), tTable.getAliasName()))) {
                                                                table = tTable;
                                                                break;
                                                        }
                                                }
                                        }

                                        if (table == null) {
                                                for (int j = 0; j < tableList.size(); j++) {
                                                        if (table != null)
                                                                break;

                                                        TTable tTable = tableList.getTable(j);
                                                        Object model = ModelBindingManager.get().getModel(tTable);
                                                        if (model instanceof Table) {
                                                                Table tableModel = (Table) model;
                                                                // STRUCT tree: a field read is owned by the table that declares its column, as a
                                                                // whole-column read would be (customer.address.city with only orders declaring customer)
                                                                String structBase = nestedProfile().buildsDeclaredTree()
                                                                                && tableModel.isCreateTable() ? getStructFieldBaseName(columnName) : null;
                                                                for (int z = 0; tableModel.getColumns() != null
                                                                                && z < tableModel.getColumns().size(); z++) {
                                                                        TableColumn refer = tableModel.getColumns().get(z);
                                                                        if (structBase != null && DlineageUtil.sameName(ESQLDataObjectType.dotColumn,
                                                                                        refer.getName(), structBase)) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                        if (DlineageUtil.sameColumnName(refer.getName(), columnName)) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                        if (refer.hasStarLinkColumn()) {
                                                                                for (TObjectName linkColumn : refer.getStarLinkColumnList()) {
                                                                                        if (DlineageUtil.sameColumnName(linkColumn, columnName)) {
                                                                                                table = tTable;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        } else if (model instanceof QueryTable) {
                                                                QueryTable tableModel = (QueryTable) model;
                                                                for (int z = 0; tableModel.getColumns() != null
                                                                                && z < tableModel.getColumns().size(); z++) {
                                                                        ResultColumn refer = tableModel.getColumns().get(z);
                                                                        // Try FieldPath-based matching first
                                                                        String structFullName = getStructFieldFullName(columnName);
                                                                        if (structFullName != null) {
                                                                                String baseName = getStructFieldBaseName(columnName);
                                                                                if (baseName != null && DlineageUtil.columnMatches(refer, baseName)) {
                                                                                        table = tTable;
                                                                                        break;
                                                                                }
                                                                        }
                                                                        List<String> splits = SQLUtil.parseNames(columnName.toString());
                                                                        if (splits.size() > 1 && EDbVendor.dbvbigquery == getOption().getVendor()) {
                                                                                if (DlineageUtil.columnMatches(refer, splits.get(0))) {
                                                                                        table = tTable;
                                                                                        break;
                                                                                }
                                                                        }
                                                                        else if (DlineageUtil.columnMatches(refer, columnName)) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                        if (refer.hasStarLinkColumn()) {
                                                                                for (TObjectName linkColumn : refer.getStarLinkColumnList()) {
                                                                                        if (DlineageUtil.sameColumnName(linkColumn, columnName)) {
                                                                                                table = tTable;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }

                                // STRUCT tree: a field read TSQLResolver2 could not place belongs to the one relation that declares its
                                // base column, and plan rule R3: a field read whose column TSQLResolver2 found in several relations has no
                                // proven owner; neither the parse's first guess nor a same-named column of some table settles it.
                                table = structFieldReadTable(table, columnName, tableList);

                                if (columnName.getTableToken() == null && DlineageUtil.isStarName((columnName))) {
                                        if (columnName == starOfTables) {
                                                tables.addAll(starOfTablesRead);
                                        } else if (!hasJoin(stmt)) {
                                                tables.add(table);
                                        } else {
                                                for (int j = 0; j < tableList.size(); j++) {
                                                        tables.add(tableList.getTable(j));
                                                }
                                        }
                                } else if (table != null) {
                                        tables.add(table);
                                }

                                // 此处特殊处理，多表关联无法找到 column 所属的 Table, tTable.getLinkedColumns
                                // 也找不到，退而求其次采用第一个表

                                if (stmt.getParentStmt() != null && isApplyJoin(stmt.getParentStmt())
                                                && (tableList != null && tableList.size() > 0)) {
                                        stmt = stmt.getParentStmt();
                                        TTable applyTable = tableList.getTable(0);
                                        if (modelManager.getModel(table) == null) {
                                                modelFactory.createTable(applyTable);
                                        }
                                }

                                if (columnName.toString().indexOf(".")==-1 && isConstant(columnName)) {
                                        boolean isConstant = true;
                                        if (columnName.getSourceTable() != null) {
                                                Table tableModel = modelManager.getTableByName(
                                                                DlineageUtil.getTableIdentityKey(columnName.getSourceTable().getTableName().toString()));
                                                if (tableModel != null && tableModel.getColumns() != null) {
                                                        for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                                if (sameTableColumn(columnName, tableModel.getColumns().get(j))) {
                                                                        isConstant = false;
                                                                        break;
                                                                }
                                                        }
                                                }
                                        }

                                        if (isConstant) {
                                                if (option.isShowConstantTable()) {
                                                        Table constantTable = modelFactory.createConstantsTable(stmtStack.peek());
                                                        TableColumn tableColumn = modelFactory.createTableColumn(constantTable, columnName, false);
                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                }
                                                continue;
                                        }
                                }

                                if (tableList != null && tableList.size() != 0 && tables.size() == 0
                                                && !(isBuiltInFunctionName(columnName) && isFromFunction(columnName))) {
                                        if (modelManager.getModel(stmt) instanceof ResultSet) {
                                                ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt);
                                                boolean find = false;
                                                for (ResultColumn resultColumn : resultSetModel.getColumns()) {
                                                        if(resultColumn.equals(modelObject)) {
                                                                continue;
                                                        }
                                                        if (!TSQLEnv.isAliasReferenceForbidden.get(option.getVendor())) {
                                                                if (isAliasReference(columnName, resultColumn)) {
                                                                        if (resultColumn.getColumnObject() != null) {
                                                                                int startToken = resultColumn.getColumnObject().getStartToken().posinlist;
                                                                                int endToken = resultColumn.getColumnObject().getEndToken().posinlist;
                                                                                if (columnName.getStartToken().posinlist >= startToken
                                                                                                && columnName.getEndToken().posinlist <= endToken) {
                                                                                        continue;
                                                                                }
                                                                        }
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        find = true;
                                                                        break;
                                                                }
                                                        }
                                                }
                                                if (find) {
                                                        continue;
                                                }
                                        }

                                        // Structured-dataflow outer field resolution: an unresolved
                                        // reference like nodes1.key (or t.nodes1.key) may be a
                                        // struct-field projection produced by a structured generator
                                        // (e.g. Spark explode(from_json(...))) in a visible subquery.
                                        // Link directly to the matching FunctionResultColumn so the
                                        // exact source path (nodes[*].key) flows through.
                                        if (tryAppendStructuredFieldRelation(relation, columnName, tableList)) {
                                                continue;
                                        }

                                        TObjectName pseudoTableName = new TObjectName();
                                        // Use qualified prefix from column name if available (e.g., sch.pk_constv2 from sch.pk_constv2.c_cdsl)
                                        // Otherwise fall back to default pseudo table name
                                        String qualifiedPrefix = getQualifiedPrefixFromColumn(columnName);
                                        pseudoTableName.setString(qualifiedPrefix != null ? qualifiedPrefix : "pseudo_table_include_orphan_column");
                                        Table pseudoTable = modelFactory.createTableByName(pseudoTableName);
                                        pseudoTable.setPseudo(true);
                                        TableColumn pseudoTableColumn = modelFactory.createTableColumn(pseudoTable, columnName, true);

                                        // If not linking to first table and column has qualified prefix (3-part name like sch.pkg.col),
                                        // add the pseudo table column as source
                                        if (!isLinkOrphanColumnToFirstTable() && pseudoTableColumn != null && qualifiedPrefix != null) {
                                                SqllrObservations decided = SqllrObservations.current();
                                                if (decided != null) {
                                                        decided.decision(SqllrObservations.DECISION_ORPHAN_PSEUDO_TABLE, columnName, pseudoTable,
                                                                        "an orphan column with a qualified prefix");
                                                }
                                                if (isOut) {
                                                        relation.setTarget(new TableColumnRelationshipElement(pseudoTableColumn));
                                                } else {
                                                        relation.addSource(new TableColumnRelationshipElement(pseudoTableColumn));
                                                }
                                        }

                                        if (isLinkOrphanColumnToFirstTable()) {
                                                TTable orphanTable = tableList.getTable(0);
                                                SqllrObservations decided = SqllrObservations.current();
                                                if (decided != null) {
                                                        decided.decision(SqllrObservations.DECISION_ORPHAN_FIRST_TABLE, columnName, orphanTable,
                                                                        "linkOrphanColumnToFirstTable");
                                                }
                                                tables.add(orphanTable);
                                                Object tableModel = modelManager.getModel(orphanTable);
                                                if (tableModel == null) {
                                                        if(orphanTable.getSubquery()!=null) {
                                                                QueryTable queryTable = modelFactory.createQueryTable(orphanTable);
                                                                TSelectSqlStatement subquery = orphanTable.getSubquery();
                                                                analyzeSelectStmt(subquery);
                                                        }
                                                        else {
                                                                tableModel = modelFactory.createTable(orphanTable);
                                                        }
                                                }
                                                if (tableModel instanceof Table) {
                                                        TableColumn orphanColum = modelFactory.createTableColumn((Table) tableModel, columnName, false);
                                                        if(orphanColum!=null) {
                                                                ErrorInfo errorInfo = new ErrorInfo();
                                                                errorInfo.setErrorType(ErrorInfo.LINK_ORPHAN_COLUMN);
                                                                errorInfo.setErrorMessage("Link orphan column [" + columnName.toString()
                                                                                + "] to the first table [" + orphanTable.getFullNameWithAliasString() + "]");
                                                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(columnName.getStartToken().lineNo,
                                                                                columnName.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                                                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(columnName.getEndToken().lineNo,
                                                                                columnName.getEndToken().columnNo + columnName.getEndToken().getAstext().length(),
                                                                                ModelBindingManager.getGlobalHash()));
                                                                errorInfo.fillInfo(this);
                                                                errorInfos.add(errorInfo);
                                                        }
                                                        if (orphanTable.getSubquery() != null) {
                                                                TSelectSqlStatement subquery = orphanTable.getSubquery();
                                                                if (lastItemIsStar(subquery.getResultColumnList()) && subquery.getTables().size() == 1) {
                                                                        TTable subqueryTable = subquery.getTables().getTable(0);
                                                                        Object sourceTable = modelManager.getModel(subqueryTable);
                                                                        if(sourceTable instanceof Table) {
                                                                                modelFactory.createTableColumn((Table) sourceTable, columnName, false);
                                                                        }
                                                                        else if(sourceTable instanceof ResultSet) {
                                                                                modelFactory.createResultColumn((ResultSet) sourceTable, columnName, false);
                                                                        }
                                                                }
                                                        }
                                                        else if (orphanTable.getCTE()!=null && orphanTable.getCTE().getSubquery() != null) {
                                                                TSelectSqlStatement subquery = orphanTable.getCTE().getSubquery();
                                                                if (lastItemIsStar(subquery.getResultColumnList()) && subquery.getTables().size() == 1) {
                                                                        TTable subqueryTable = subquery.getTables().getTable(0);
                                                                        Object sourceTable = modelManager.getModel(subqueryTable);
                                                                        if(sourceTable instanceof Table) {
                                                                                modelFactory.createTableColumn((Table) sourceTable, columnName, false);
                                                                        }
                                                                        else if(sourceTable instanceof ResultSet) {
                                                                                modelFactory.createResultColumn((ResultSet) sourceTable, columnName, false);
                                                                        }
                                                                }
                                                        }
                                                }
                                                
                                                linkedFirstTable = true;
                                        }
                                }
                        }

                        for (int k = 0; k < tables.size(); k++) {
                                TTable table = tables.get(k);
                                if (table != null) {
                                        Object object = modelManager.getModel(table);
                                        if(object instanceof PivotedTable) {
                                                TPivotClause clause = (TPivotClause)((PivotedTable)object).getGspObject();
                                                if(clause.getAliasClause()!=null) {
                                                        object = modelManager.getModel(clause.getAliasClause());
                                                }
                                        }
                                        if (object == null && table.getTableType() == ETableSource.objectname) {
                                                if (table.getCTE() != null) {
                                                        QueryTable queryTable = modelFactory.createQueryTable(table);
                                                        TSelectSqlStatement subquery = table.getCTE().getSubquery();
                                                        analyzeSelectStmt(subquery);
                                                        ResultSet resultSetModel = (ResultSet) modelManager.getModel(subquery);

                                                        if (resultSetModel != null && resultSetModel != queryTable
                                                                        && !resultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                                impactRelation.setEffectType(EffectType.select);
                                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                                resultSetModel.getRelationRows()));
                                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                                queryTable.getRelationRows()));
                                                        }

                                                        if (resultSetModel != null && resultSetModel != queryTable) {
                                                                for (int j = 0; j < resultSetModel.getColumns().size(); j++) {
                                                                        ResultColumn sourceColumn = resultSetModel.getColumns().get(j);
                                                                        ResultColumn targetColumn = modelFactory.createSelectSetResultColumn(queryTable,
                                                                                        sourceColumn);

                                                                        DataFlowRelationship queryRalation = modelFactory.createDataFlowRelation();
                                                                        queryRalation.setEffectType(EffectType.select);
                                                                        queryRalation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                                        queryRalation.addSource(new ResultColumnRelationshipElement(sourceColumn));
                                                                }
                                                        }
                                                        
                                                        object = queryTable;
                                                        
                                                } else {
                                                        object = modelFactory.createTable(table);
                                                }
                                        }
                                        if (object instanceof Function) {
                                                relation.addSource(new ResultColumnRelationshipElement(((Function)object).getColumns().get(0)));
                                                continue;
                                        } else if (object instanceof ResultSet && !(object instanceof QueryTable)) {
                                                //Object tableModel = modelManager.getModel(columnName.getSourceTable());
                                                appendResultColumnRelationSource(modelObject, relation, columnIndex, columnName,
                                                                (ResultSet)object);
                                                if(table.getTableType() == ETableSource.function && !relation.getSources().isEmpty()) {
                                                        relation.getSources().stream().reduce((first, second) -> second).get().addTransform(Transform.FUNCTION, table);
                                                }
                                                continue;
                                        }
                                        else if (object instanceof Table) {
                                                Table tableModel = (Table) modelManager.getModel(table);
                                                if (tableModel != null) {
                                                        if (!isStar && DlineageUtil.isStarName((columnName))) {
                                                                TObjectName[] columns = modelManager.getTableColumns(table);
                                                                for (int j = 0; j < columns.length; j++) {
                                                                        TObjectName objectName = columns[j];
                                                                        if (objectName == null || (DlineageUtil.isStarName((objectName)) && tableModel.isDetermined())) {
                                                                                continue;
                                                                        }
                                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel, objectName,
                                                                                        false);
                                                                        if(columnModel == null) {
                                                                                continue;
                                                                        }
                                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                }
                                                        } else {
                                                                if (DlineageUtil.isStarName((columnName)) && !tableModel.getColumns().isEmpty()) {
                                                                        Map<String, Pair<String, TExpression>> replaceAsIdentifierMap = new HashMap<String, Pair<String, TExpression>>();
                                                                        Map<String, TObjectName> replaceColumnMap = new HashMap<String, TObjectName>();
                                                                        if(modelObject instanceof ResultColumn && ((ResultColumn)modelObject).getColumnObject() instanceof TResultColumn) {
                                                                                TResultColumn resultColumn =  (TResultColumn )((ResultColumn)modelObject).getColumnObject();
                                                                                if(resultColumn.getReplaceExprAsIdentifiers()!=null && resultColumn.getReplaceExprAsIdentifiers().size()>0) {
                                                                                        for(TReplaceExprAsIdentifier replace: resultColumn.getReplaceExprAsIdentifiers()) {
                                                                                                replaceAsIdentifierMap.put(replace.getIdentifier().toString(), new Pair<String, TExpression>(resultColumn.getExpr().getExceptReplaceClause().toString(), replace.getExpr()));
                                                                                                replaceColumnMap.put(replace.getIdentifier().toString(), replace.getIdentifier());
                                                                                        }
                                                                                        ResultSet resultSet = ((ResultColumn)modelObject).getResultSet();
                                                                                        if(tableModel.isDetermined()) {
                                                                                                resultSet.getColumns().clear();
                                                                                        }
                                                                                }
                                                                        }
                                                                        
                                                                        for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                                                TableColumn columnModel = tableModel.getColumns().get(j);
                                                                                if (exceptColumnList != null) {
                                                                                        boolean flag = false;
                                                                                        for (TObjectName objectName : exceptColumnList) {
                                                                                                if (DlineageUtil.sameColumnName(objectName, columnModel.getColumnObject())) {
                                                                                                        flag = true;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                        if (flag) {
                                                                                                continue;
                                                                                        }
                                                                                }
                                                                                
                                                                                if (replaceAsIdentifierMap.containsKey(tableModel.getColumns().get(j).getName())) {
                                                                                        Pair<String, TExpression> expr = replaceAsIdentifierMap.get(tableModel.getColumns().get(j).getName());
                                                                                        ResultSet resultSet = ((ResultColumn)modelObject).getResultSet();
                                                                                        ResultColumn resultColumn = modelFactory.createResultColumn(resultSet, replaceColumnMap.get(tableModel.getColumns().get(j).getName()));
                                                                                        Transform transform = new Transform();
                                                                                        transform.setType(Transform.EXPRESSION);
                                                                                        TObjectName expression = new TObjectName();
                                                                                        expression.setString(expr.first);
                                                                                transform.setCode(expression);
                                                                                        resultColumn.setTransform(transform);
                                                                                        analyzeResultColumnExpressionRelation(resultColumn, expr.second);
                                                                                } else {
                                                                                        if(!replaceAsIdentifierMap.isEmpty()) {
                                                                                                ResultSet resultSet = ((ResultColumn) modelObject).getResultSet();
                                                                                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSet,
                                                                                                                columnModel.getColumnObject());
                                                                                                DataFlowRelationship relation1 = modelFactory.createDataFlowRelation();
                                                                                                relation1.setEffectType(effectType);
                                                                                                relation1.setProcess(process);
                                                                                                relation1.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                relation1.addSource(new TableColumnRelationshipElement(columnModel));
                                                                                        }
                                                                                        else {
                                                                                                relation.addSource(
                                                                                                        new TableColumnRelationshipElement(columnModel));
                                                                                        }
                                                                                }
                                                                        }

                                                                        if (isStar && showStar) {
                                                                                TableColumn columnModel = modelFactory.createTableColumn(tableModel, columnName,
                                                                                                false);
                                                                                if (columnModel == null) {
                                                                                        if(tableModel.isCreateTable()) {
                                                                                                for (TableColumn tableColumn : tableModel.getColumns()) {
                                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                        relation.setShowStarRelation(true);
                                                                                                }
                                                                                        }
                                                                                } else {
                                                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                                        relation.setShowStarRelation(true);
                                                                                }
                                                                        }
                                                                } else {
                                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel, columnName,
                                                                                        false);
                                                                        if(columnModel == null) {
                                                                                if(tableModel.isCreateTable()) {
                                                                                        boolean flag = false;
                                                                                        // Try FieldPath-based matching first for BigQuery/Redshift struct fields
                                                                                        String structFullName = getStructFieldFullName(columnName);
                                                                                        if (structFullName != null && !flag) {
                                                                                                for (TableColumn tableColumn : tableModel.getColumns()) {
                                                                                                        if (tableColumn.isStruct()
                                                                                                                && DlineageUtil.sameColumnPath(tableColumn.getName(), structFullName)) {
                                                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                                flag = true;
                                                                                                                if (modelObject instanceof ResultColumn) {
                                                                                                                        ((ResultColumn) modelObject).setStruct(true);
                                                                                                                } else if (modelObject instanceof TableColumn) {
                                                                                                                        ((TableColumn) modelObject).setStruct(true);
                                                                                                                }
                                                                                                                break;
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                        if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvbigquery || ModelBindingManager.getGlobalVendor() == EDbVendor.dbvredshift) {
                                                                                                for (TableColumn tableColumn : tableModel.getColumns()) {
                                                                                                        if(tableColumn.isStruct()) {
                                                                                                                List<String> names = SQLUtil.parseNames(tableColumn.getName());
                                                                                                                if (modelObject instanceof TableColumn) {
                                                                                                                        TableColumn targetColumn = (TableColumn) modelObject;
                                                                                                                        if (targetColumn.isStruct()) {
                                                                                                                                List<String> targetNames = SQLUtil
                                                                                                                                                .parseNames(targetColumn.getName());
                                                                                                                                if (!DlineageUtil.sameColumnName(targetNames.get(0), names.get(0))) {
                                                                                                                                        continue;
                                                                                                                                }
                                                                                                                        }
                                                                                                                }
                                                                                                                else if (modelObject instanceof ResultColumn) {
                                                                                                                        ResultColumn targetColumn = (ResultColumn) modelObject;
                                                                                                                        if (targetColumn.isStruct()) {
                                                                                                                                List<String> targetNames = SQLUtil
                                                                                                                                                .parseNames(targetColumn.getName());
                                                                                                                                if (!DlineageUtil.sameColumnName(targetNames.get(0), names.get(0))) {
                                                                                                                                        continue;
                                                                                                                                }
                                                                                                                        }
                                                                                                                }
                                                                                                                for(String name: names) {
                                                                                                                        if (DlineageUtil.sameColumnName(name, modelObject.toString())) {
                                                                                                                                relation.addSource(
                                                                                                                                                new TableColumnRelationshipElement(tableColumn));
                                                                                                                                flag = true;
                                                                                                                                if (modelObject instanceof ResultColumn) {
                                                                                                                                        ((ResultColumn)modelObject).setStruct(true);
                                                                                                                                }
                                                                                                                                else if (modelObject instanceof TableColumn) {
                                                                                                                                        ((TableColumn)modelObject).setStruct(true);
                                                                                                                                }
                                                                                                                                break;
                                                                                                                        }
                                                                                                                }

                                                                                                                // a STRUCT tree element (items[*]) reads its fields as nodes, never as a
                                                                                                                // column named after the element and the read
                                                                                                                if (!flag && tableModel.getColumns().size() == 1 && tableModel
                                                                                                                                .getColumns().get(0).getSourceColumn() != null
                                                                                                                                && !tableModel.getColumns().get(0).getSourceColumn().isFieldPathNode()) {
                                                                                                                        TableColumn sourceColumn = tableModel
                                                                                                                                        .getColumns().get(0).getSourceColumn();
                                                                                                                        Table sourceTable = sourceColumn.getTable();
                                                                                                                        TObjectName sourceColumnName = new TObjectName();
                                                                                                                        sourceColumnName.setString(sourceColumn.getName() + "."
                                                                                                                                        + columnName.getColumnNameOnly());
                                                                                                                        TableColumn sourceTableColumn = modelFactory.createTableColumn(sourceTable, sourceColumnName, true);
                                                                                                                        relation.addSource(
                                                                                                                                        new TableColumnRelationshipElement(sourceTableColumn));
                                                                                                                        flag = true;
                                                                                                                        break;
                                                                                                                }
                                                                                                        }
                                                                                                        else if (DlineageUtil.sameColumnName(tableColumn.getName(), modelObject.toString())) {
                                                                                                                relation.addSource(
                                                                                                                                new TableColumnRelationshipElement(tableColumn));
                                                                                                                flag = true;
                                                                                                                break;
                                                                                                        }
                                                                                                }
                                                                                                if (modelObject instanceof TableColumn) {
                                                                                                        TableColumn column = (TableColumn) modelObject;
                                                                                                        for (TableColumn tableColumn : tableModel.getColumns()) {
                                                                                                                if (tableColumn.getColumnIndex() == null) {
                                                                                                                        continue;
                                                                                                                }
                                                                                                                if (tableColumn.getName().toLowerCase(Locale.ROOT)
                                                                                                                                .indexOf(column.getName().toLowerCase(Locale.ROOT)) == -1
                                                                                                                                && tableColumn.getName().toLowerCase(Locale.ROOT)
                                                                                                                                                .indexOf(column.getColumnObject().toString()
                                                                                                                                                                .toLowerCase(Locale.ROOT)) == -1) {
                                                                                                                        continue;
                                                                                                                }
                                                                                                                flag = true;
                                                                                                                relation.addSource(
                                                                                                                                new TableColumnRelationshipElement(tableColumn));
                                                                                                                relation.setShowStarRelation(true);
                                                                                                        }
                                                                                                        if (flag)
                                                                                                                break;

                                                                                                } else if (modelObject instanceof ResultColumn) {
                                                                                                        ResultColumn column = (ResultColumn) modelObject;
                                                                                                        for (TableColumn tableColumn : tableModel.getColumns()) {
                                                                                                                if (tableColumn.getColumnIndex() == null) {
                                                                                                                        continue;
                                                                                                                }
                                                                                                                if (tableColumn.getName().toLowerCase(Locale.ROOT)
                                                                                                                                .indexOf(column.getName().toLowerCase(Locale.ROOT)) == -1
                                                                                                                                && tableColumn.getName().toLowerCase(Locale.ROOT)
                                                                                                                                                .indexOf(column.getColumnObject().toString()
                                                                                                                                                                .toLowerCase(Locale.ROOT)) == -1) {
                                                                                                                        continue;
                                                                                                                }
                                                                                                                flag = true;
                                                                                                                relation.addSource(
                                                                                                                                new TableColumnRelationshipElement(tableColumn));
                                                                                                                relation.setShowStarRelation(true);
                                                                                                        }
                                                                                                        if (flag)
                                                                                                                break;

                                                                                                }
                                                                                        }
                                                                                        if (!flag 
                                                                                                        && (isStar 
                                                                                                                        || DlineageUtil.sameColumnName(columnName, tableModel.getName())
                                                                                                                        || DlineageUtil.sameColumnName(columnName, tableModel.getAlias()))) {
                                                                                                for (TableColumn tableColumn : tableModel.getColumns()) {
                                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                        relation.setShowStarRelation(true);
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                        else {
                                                                                if (linkedFirstTable || columnModel.getCandidateParents() != null) {
                                                                                        if (columnName.getCandidateTables() != null
                                                                                                        && columnName.getCandidateTables().size() > 1) {
                                                                                                List<Object> candidateParents = new ArrayList<Object>();
                                                                                                for(TTable tableItem: columnName.getCandidateTables()) {
                                                                                                        Object model = modelManager.getModel(tableItem);
                                                                                                        if(model!=null) {
                                                                                                                candidateParents.add(model);
                                                                                                        }
                                                                                                }
                                                                                                if (candidateParents.size() > 1) {
                                                                                                        columnModel.setCandidateParents(candidateParents);
                                                                                                }
                                                                                        }
                                                                                }
                                                                                relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                                relation.setShowStarRelation(true);
                                                                                if(modelObject instanceof TableColumn) {
                                                                                        TableColumn targetTableColumn = (TableColumn)modelObject;
                                                                                        if(targetTableColumn.getTable().getSubType() == SubType.unnest && targetTableColumn.getTable().getColumns().size() == 1) {
                                                                                                targetTableColumn.setSourceColumn(columnModel);
                                                                                                targetTableColumn.setStruct(true);
                                                                                        }
                                                                                }
                                                                                if (columnName.getSourceTable() != null
                                                                                                && columnName.getSourceTable().getTableType() == ETableSource.function) {
                                                                                        analyzeTableColumn(columnModel, columnName.getSourceTable().getFuncCall(),
                                                                                                        effectType);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        } else if (modelManager.getModel(table) instanceof QueryTable) {
                                                QueryTable queryTable = (QueryTable) modelManager.getModel(table);

                                                TObjectNameList cteColumns = null;
                                                TSelectSqlStatement subquery = null;
                                                if (queryTable.getTableObject().getCTE() != null) {
                                                        subquery = queryTable.getTableObject().getCTE().getSubquery();
                                                        cteColumns = queryTable.getTableObject().getCTE().getColumnList();
                                                } else if (queryTable.getTableObject().getAliasClause() != null
                                                                && queryTable.getTableObject().getAliasClause().getColumns() != null) {

                                                } else if (queryTable.getTableObject().getTableExpr() != null
                                                                && queryTable.getTableObject().getTableExpr().getSubQuery() != null) {
                                                        subquery = queryTable.getTableObject().getTableExpr().getSubQuery();
                                                } else {
                                                        subquery = queryTable.getTableObject().getSubquery();
                                                }

                                                if (cteColumns != null) {
                                                        for (int j = 0; j < cteColumns.size(); j++) {
                                                                modelFactory.createResultColumn(queryTable, cteColumns.getObjectName(j));
                                                        }
                                                }

                                                if (linkStructFieldReadThroughQuery(queryTable, subquery, columnName, modelObject, relation)) {
                                                        continue;
                                                }

                                                if (subquery != null && subquery.isCombinedQuery()) {
                                                        SelectSetResultSet selectSetResultSetModel = (SelectSetResultSet) modelManager
                                                                        .getModel(subquery);

                                                        if (selectSetResultSetModel != null
                                                                        && !selectSetResultSetModel.getRelationRows().getHoldRelations().isEmpty()) {
                                                                ImpactRelationship impactRelation = modelFactory.createImpactRelation();
                                                                impactRelation.setEffectType(EffectType.select);
                                                                impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                                selectSetResultSetModel.getRelationRows()));
                                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                                queryTable.getRelationRows()));
                                                        }

                                                        if (selectSetResultSetModel != null) {
                                                                if (isWildcardReference(columnName)) {
                                                                        Map<String, Pair<String, TExpression>> replaceAsIdentifierMap = new HashMap<String, Pair<String, TExpression>>();
                                                                        Map<String, TObjectName> replaceColumnMap = new HashMap<String, TObjectName>();
                                                                        if(modelObject instanceof ResultColumn && ((ResultColumn)modelObject).getColumnObject() instanceof TResultColumn) {
                                                                                TResultColumn resultColumn =  (TResultColumn )((ResultColumn)modelObject).getColumnObject();
                                                                                if(resultColumn.getReplaceExprAsIdentifiers()!=null && resultColumn.getReplaceExprAsIdentifiers().size()>0) {
                                                                                        for(TReplaceExprAsIdentifier replace: resultColumn.getReplaceExprAsIdentifiers()) {
                                                                                                replaceAsIdentifierMap.put(replace.getIdentifier().toString(), new Pair<String, TExpression>(resultColumn.getExpr().getExceptReplaceClause().toString(), replace.getExpr()));
                                                                                                replaceColumnMap.put(replace.getIdentifier().toString(), replace.getIdentifier());
                                                                                        }
                                                                                        ResultSet resultSet = ((ResultColumn)modelObject).getResultSet();
                                                                                        if(selectSetResultSetModel.isDetermined()) {
                                                                                                resultSet.getColumns().clear();
                                                                                        }
                                                                                }
                                                                        }
                                                                        
                                                                        
                                                                        for (int j = 0; j < selectSetResultSetModel.getColumns().size(); j++) {
                                                                                ResultColumn sourceColumn = selectSetResultSetModel.getColumns().get(j);
                                                                                if (cteColumns != null) {
                                                                                        if (j < cteColumns.size()) {
                                                                                                ResultColumn targetColumn = queryTable.getColumns().get(j);

                                                                                                if (exceptColumnList != null) {
                                                                                                        boolean flag = false;
                                                                                                        for (TObjectName objectName : exceptColumnList) {
                                                                                                                if (DlineageUtil.sameColumnName(objectName, targetColumn.getName())) {
                                                                                                                        flag = true;
                                                                                                                        break;
                                                                                                                }
                                                                                                        }
                                                                                                        if (flag) {
                                                                                                                continue;
                                                                                                        }
                                                                                                }

                                                                                                if (replaceAsIdentifierMap.containsKey(targetColumn.getName())) {
                                                                                                        Pair<String, TExpression> expr = replaceAsIdentifierMap.get(targetColumn.getName());
                                                                                                        ResultSet resultSet = ((ResultColumn)modelObject).getResultSet();
                                                                                                        ResultColumn resultColumn = modelFactory.createResultColumn(resultSet, replaceColumnMap.get(targetColumn.getName()));
                                                                                                        Transform transform = new Transform();
                                                                                                        transform.setType(Transform.EXPRESSION);
                                                                                                        TObjectName expression = new TObjectName();
                                                                                                        expression.setString(expr.first);
                                                                                                transform.setCode(expression);
                                                                                                        resultColumn.setTransform(transform);
                                                                                                        analyzeResultColumnExpressionRelation(resultColumn, expr.second);
                                                                                                } else {
                                                                                                        if(!replaceAsIdentifierMap.isEmpty()) {
                                                                                                                ResultSet resultSet = ((ResultColumn) modelObject).getResultSet();
                                                                                                                TObjectName resultColumnName = new TObjectName();
                                                                                                                resultColumnName.setString(targetColumn.getName());
                                                                                                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSet,
                                                                                                                                resultColumnName);
                                                                                                                DataFlowRelationship relation1 = modelFactory.createDataFlowRelation();
                                                                                                                relation1.setEffectType(effectType);
                                                                                                                relation1.setProcess(process);
                                                                                                                relation1.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                relation1.addSource(new ResultColumnRelationshipElement(targetColumn));
                                                                                                        }
                                                                                                        else {
                                                                                                                relation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(targetColumn));
                                                                                                        }
                                                                                                }
                                                                                                
                                                                                        }
                                                                                } else {
                                                                                        ResultColumn targetColumn = modelFactory
                                                                                                        .createSelectSetResultColumn(queryTable, sourceColumn);

                                                                                        DataFlowRelationship combinedQueryRelation = modelFactory
                                                                                                        .createDataFlowRelation();
                                                                                        combinedQueryRelation.setEffectType(effectType);
                                                                                        combinedQueryRelation
                                                                                                        .setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                                                        combinedQueryRelation
                                                                                                        .addSource(new ResultColumnRelationshipElement(sourceColumn));

                                                                                        relation.addSource(new ResultColumnRelationshipElement(targetColumn));
                                                                                }
                                                                        }
                                                                        break;
                                                                } else {
                                                                        boolean flag = false;

                                                                        for (int j = 0; j < selectSetResultSetModel.getColumns().size(); j++) {
                                                                                ResultColumn sourceColumn = selectSetResultSetModel
                                                                                                .getColumns().get(j);
                                                                                List<String> splits = SQLUtil.parseNames(columnName.toString());        
                                                                                if (splits.size() > 1 && EDbVendor.dbvbigquery == getOption().getVendor()) {
                                                                                        if (DlineageUtil.sameColumnSegment(sourceColumn.getName(), splits.get(0))
                                                                                                        || DlineageUtil.sameColumnSegment(sourceColumn.getName(), splits.get(1))) {
                                                                                                ResultColumn targetColumn = modelFactory
                                                                                                                .createSelectSetResultColumn(queryTable, sourceColumn);

                                                                                                DataFlowRelationship combinedQueryRelation = modelFactory
                                                                                                                .createDataFlowRelation();
                                                                                                combinedQueryRelation.setEffectType(effectType);
                                                                                                combinedQueryRelation.setTarget(
                                                                                                                new ResultColumnRelationshipElement(targetColumn));
                                                                                                combinedQueryRelation.addSource(
                                                                                                                new ResultColumnRelationshipElement(sourceColumn));

                                                                                                relation.addSource(
                                                                                                                new ResultColumnRelationshipElement(targetColumn));
                                                                                                flag = true;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                                else if (DlineageUtil.sameColumnName(sourceColumn.getName(), columnName)) {
                                                                                        ResultColumn targetColumn = modelFactory
                                                                                                        .createSelectSetResultColumn(queryTable, sourceColumn);

                                                                                        DataFlowRelationship combinedQueryRelation = modelFactory
                                                                                                        .createDataFlowRelation();
                                                                                        combinedQueryRelation.setEffectType(effectType);
                                                                                        combinedQueryRelation
                                                                                                        .setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                                                        combinedQueryRelation
                                                                                                        .addSource(new ResultColumnRelationshipElement(sourceColumn));

                                                                                        relation.addSource(new ResultColumnRelationshipElement(targetColumn));
                                                                                        flag = true;
                                                                                        break;
                                                                                }
                                                                                else if (sourceColumn instanceof SelectSetResultColumn && ((SelectSetResultColumn)sourceColumn).getAliasSet().size() > 1) {
                                                                                        for (String alias : ((SelectSetResultColumn)sourceColumn).getAliasSet()) {
                                                                                                if (DlineageUtil.sameColumnName(alias, columnName)) {
                                                                                                        ResultColumn targetColumn = modelFactory
                                                                                                                        .createSelectSetResultColumn(queryTable, sourceColumn);

                                                                                                        DataFlowRelationship combinedQueryRelation = modelFactory
                                                                                                                        .createDataFlowRelation();
                                                                                                        combinedQueryRelation.setEffectType(effectType);
                                                                                                        combinedQueryRelation.setTarget(
                                                                                                                        new ResultColumnRelationshipElement(targetColumn));
                                                                                                        combinedQueryRelation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(sourceColumn));

                                                                                                        relation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(targetColumn));
                                                                                                        flag = true;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                        if (flag) {
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }

                                                                        if (flag) {
                                                                                break;
                                                                        } else if (columnIndex != -1) {
                                                                                for (int j = 0; j < selectSetResultSetModel.getColumns().size(); j++) {
                                                                                        ResultColumn sourceColumn = selectSetResultSetModel.getColumns().get(j);
                                                                                        if (sourceColumn.hasStarLinkColumn()) {
                                                                                                if (cteColumns != null) {
                                                                                                        // the column list names the CTE's columns: a reference reads the column of its
                                                                                                        // name, not the one at the position of the set operation's star (Mantis 4914)
                                                                                                        ResultColumn namedColumn = null;
                                                                                                        for (ResultColumn cteColumn : queryTable.getColumns()) {
                                                                                                                if (namedColumn == null && DlineageUtil.sameColumnName(cteColumn.getName(), columnName)) {
                                                                                                                        namedColumn = cteColumn;
                                                                                                                }
                                                                                                        }
                                                                                                        if (namedColumn != null) {
                                                                                                                relation.addSource(new ResultColumnRelationshipElement(namedColumn));
                                                                                                        } else if (j < cteColumns.size()) {
                                                                                                                ResultColumn targetColumn = queryTable.getColumns().get(j);
                                                                                                                relation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(targetColumn));
                                                                                                        }
                                                                                                } 
                                                                                                else {
                                                                                                        if(sourceColumn.hasStarLinkColumn()) {
                                                                                                                for (TObjectName linkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                                                                        if (DlineageUtil.sameColumnName(linkColumn, columnName)) {
                                                                                                                                ResultColumn targetColumn = modelFactory
                                                                                                                                                .createSelectSetResultColumn(queryTable, sourceColumn);

                                                                                                                                DataFlowRelationship combinedQueryRelation = modelFactory
                                                                                                                                                .createDataFlowRelation();
                                                                                                                                combinedQueryRelation.setEffectType(effectType);
                                                                                                                                combinedQueryRelation.setTarget(
                                                                                                                                                new ResultColumnRelationshipElement(targetColumn, linkColumn));
                                                                                                                                combinedQueryRelation.addSource(
                                                                                                                                                new ResultColumnRelationshipElement(sourceColumn));

                                                                                                                                relation.addSource(
                                                                                                                                                new ResultColumnRelationshipElement(targetColumn, linkColumn));
                                                                                                                                flag = true;
                                                                                                                                break;
                                                                                                                        }
                                                                                                                }
                                                                                                        }
                                                                                                        
                                                                                                        if (!flag && sourceColumn.isStarColumn()
                                                                                                                        && branchesReadTheSameTables(subquery)) {
                                                                                                                // a name the set operation's * may hold: read it from the
                                                                                                                // star by that name, as a star of a plain subquery is read
                                                                                                                // (appendResultColumnRelationSource), so only the sources
                                                                                                                // that can have it feed the column, not every column the
                                                                                                                // star reads (Mantis 4974)
                                                                                                                if (!containsStarColumn(sourceColumn, columnName)) {
                                                                                                                        sourceColumn.bindStarLinkColumn(columnName);
                                                                                                                }
                                                                                                                ResultColumn targetColumn = modelFactory
                                                                                                                                .createSelectSetResultColumn(queryTable, sourceColumn);
                                                                                                                if (!containsStarColumn(targetColumn, columnName)) {
                                                                                                                        targetColumn.bindStarLinkColumn(columnName);
                                                                                                                }
                                                                                                                DataFlowRelationship combinedQueryRelation = modelFactory
                                                                                                                                .createDataFlowRelation();
                                                                                                                combinedQueryRelation.setEffectType(effectType);
                                                                                                                combinedQueryRelation.setTarget(
                                                                                                                                new ResultColumnRelationshipElement(targetColumn, columnName));
                                                                                                                combinedQueryRelation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(sourceColumn));
                                                                                                                relation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(targetColumn, columnName));
                                                                                                        } else if (!flag) {
                                                                                                                ResultColumn targetColumn = modelFactory
                                                                                                                                .createSelectSetResultColumn(queryTable, sourceColumn);

                                                                                                                DataFlowRelationship combinedQueryRelation = modelFactory
                                                                                                                                .createDataFlowRelation();
                                                                                                                combinedQueryRelation.setEffectType(effectType);
                                                                                                                combinedQueryRelation.setTarget(
                                                                                                                                new ResultColumnRelationshipElement(targetColumn));
                                                                                                                combinedQueryRelation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(sourceColumn));

                                                                                                                relation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(targetColumn));
                                                                                                        }
                                                                                                }
                                                                                                flag = true;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }

                                                                        if (flag) {
                                                                                break;
                                                                        } else if (columnIndex < selectSetResultSetModel.getColumns().size()
                                                                                        && columnIndex != -1) {
                                                                                ResultColumn sourceColumn = selectSetResultSetModel.getColumns()
                                                                                                .get(columnIndex);
                                                                                if (cteColumns != null) {
                                                                                        boolean flag1 = false;
                                                                                        for (ResultColumn targetColumn : queryTable.getColumns()) {
                                                                                                if (DlineageUtil.sameColumnName(targetColumn.getName(), columnName)) {
                                                                                                        relation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(targetColumn));
                                                                                                        flag1 = true;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                        if (!flag1 && columnIndex < cteColumns.size()){
                                                                                                ResultColumn targetColumn = queryTable.getColumns()
                                                                                                                .get(columnIndex);
                                                                                                relation.addSource(
                                                                                                                new ResultColumnRelationshipElement(targetColumn));
                                                                                        }
                                                                                } else {
                                                                                        ResultColumn targetColumn = modelFactory
                                                                                                        .createSelectSetResultColumn(queryTable, sourceColumn);

                                                                                        DataFlowRelationship combinedQueryRelation = modelFactory
                                                                                                        .createDataFlowRelation();
                                                                                        combinedQueryRelation.setEffectType(effectType);
                                                                                        combinedQueryRelation
                                                                                                        .setTarget(new ResultColumnRelationshipElement(targetColumn));
                                                                                        combinedQueryRelation
                                                                                                        .addSource(new ResultColumnRelationshipElement(sourceColumn));

                                                                                        relation.addSource(new ResultColumnRelationshipElement(targetColumn));
                                                                                }
                                                                                flag = true;
                                                                                break;
                                                                        }

                                                                        if (flag) {
                                                                                break;
                                                                        }
                                                                }
                                                        } else if (cteColumns != null) {
                                                                if (isWildcardReference(columnName)) {
                                                                        Map<String, Pair<String, TExpression>> replaceAsIdentifierMap = new HashMap<String, Pair<String, TExpression>>();
                                                                        Map<String, TObjectName> replaceColumnMap = new HashMap<String, TObjectName>();
                                                                        if(modelObject instanceof ResultColumn && ((ResultColumn)modelObject).getColumnObject() instanceof TResultColumn) {
                                                                                TResultColumn resultColumn =  (TResultColumn )((ResultColumn)modelObject).getColumnObject();
                                                                                if(resultColumn.getReplaceExprAsIdentifiers()!=null && resultColumn.getReplaceExprAsIdentifiers().size()>0) {
                                                                                        for(TReplaceExprAsIdentifier replace: resultColumn.getReplaceExprAsIdentifiers()) {
                                                                                                replaceAsIdentifierMap.put(replace.getIdentifier().toString(), new Pair<String, TExpression>(resultColumn.getExpr().getExceptReplaceClause().toString(), replace.getExpr()));
                                                                                                replaceColumnMap.put(replace.getIdentifier().toString(), replace.getIdentifier());
                                                                                        }
                                                                                        ResultSet resultSet = ((ResultColumn)modelObject).getResultSet();
                                                                                        
                                                                                        if (columnName.getSourceColumn() != null) {
                                                                                                Object model = modelManager.getModel(columnName.getSourceColumn());
                                                                                                if (model instanceof ResultColumn && ((ResultColumn)model).getResultSet().isDetermined()) {
                                                                                                        resultSet.getColumns().clear();
                                                                                                }
                                                                                        } else if (columnName.getSourceTable() != null) {
                                                                                                Object tableModel = modelManager.getModel(columnName.getSourceTable());
                                                                                                if (tableModel instanceof Table && ((Table)tableModel).isDetermined()) {
                                                                                                        resultSet.getColumns().clear();
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                        
                                                                        for (int j = 0; j < cteColumns.size(); j++) {
                                                                                ResultColumn targetColumn = queryTable.getColumns().get(j);

                                                                                if (exceptColumnList != null) {
                                                                                        boolean flag = false;
                                                                                        for (TObjectName objectName : exceptColumnList) {
                                                                                                if (DlineageUtil.sameColumnName(objectName, targetColumn.getName())) {
                                                                                                        flag = true;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                        if (flag) {
                                                                                                continue;
                                                                                        }
                                                                                }

                                                                                if (replaceAsIdentifierMap.containsKey(targetColumn.getName())) {
                                                                                        Pair<String, TExpression> expr = replaceAsIdentifierMap.get(targetColumn.getName());
                                                                                        ResultSet resultSet = ((ResultColumn)modelObject).getResultSet();
                                                                                        ResultColumn resultColumn = modelFactory.createResultColumn(resultSet, replaceColumnMap.get(targetColumn.getName()));
                                                                                        Transform transform = new Transform();
                                                                                        transform.setType(Transform.EXPRESSION);
                                                                                        TObjectName expression = new TObjectName();
                                                                                        expression.setString(expr.first);
                                                                                transform.setCode(expression);
                                                                                        resultColumn.setTransform(transform);
                                                                                        analyzeResultColumnExpressionRelation(resultColumn, expr.second);
                                                                                } else {
                                                                                        if(!replaceAsIdentifierMap.isEmpty()) {
                                                                                                ResultSet resultSet = ((ResultColumn) modelObject).getResultSet();
                                                                                                TObjectName resultColumnName = new TObjectName();
                                                                                                resultColumnName.setString(targetColumn.getName());
                                                                                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSet,
                                                                                                                resultColumnName);
                                                                                                DataFlowRelationship relation1 = modelFactory.createDataFlowRelation();
                                                                                                relation1.setEffectType(effectType);
                                                                                                relation1.setProcess(process);
                                                                                                relation1.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                relation1.addSource(new ResultColumnRelationshipElement(targetColumn));
                                                                                        }
                                                                                        else {
                                                                                                relation.addSource(
                                                                                                        new ResultColumnRelationshipElement(targetColumn));
                                                                                        }
                                                                                }
                                                                        }
                                                                        break;
                                                                } else {
                                                                        boolean flag = false;

                                                                        for (int j = 0; j < cteColumns.size(); j++) {
                                                                                TObjectName sourceColumn = cteColumns.getObjectName(j);

                                                                                if (DlineageUtil.sameColumnName(sourceColumn, columnName)) {
                                                                                        ResultColumn targetColumn = queryTable.getColumns().get(j);

                                                                                        relation.addSource(new ResultColumnRelationshipElement(targetColumn));
                                                                                        flag = true;
                                                                                        break;
                                                                                }
                                                                        }

                                                                        if (flag) {
                                                                                break;
                                                                        }
                                                                }
                                                        }

                                                        if (columnName.getSourceColumn() != null) {
                                                                Object model = modelManager.getModel(columnName.getSourceColumn());
                                                                if (model instanceof ResultColumn) {
                                                                        ResultColumn resultColumn = (ResultColumn) model;
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                }
                                                        } else if (columnName.getSourceTable() != null) {
                                                                Object tableModel = modelManager.getModel(columnName.getSourceTable());
                                                                if (tableModel instanceof Table) {
                                                                        Object model = modelManager
                                                                                        .getModel(new Pair<Table, TObjectName>((Table) tableModel, columnName));
                                                                        if (model instanceof TableColumn) {
                                                                                relation.addSource(new TableColumnRelationshipElement((TableColumn) model));
                                                                        }
                                                                }
                                                        }
                                                } else {
                                                        List<ResultColumn> columns = queryTable.getColumns();
                                                        if (isWildcardReference(columnName)) {
                                                                Map<String, Pair<String, TExpression>> replaceAsIdentifierMap = new HashMap<String, Pair<String, TExpression>>();
                                                                Map<String, TObjectName> replaceColumnMap = new HashMap<String, TObjectName>();
                                                                if(modelObject instanceof ResultColumn && ((ResultColumn)modelObject).getColumnObject() instanceof TResultColumn) {
                                                                        TResultColumn resultColumn =  (TResultColumn )((ResultColumn)modelObject).getColumnObject();
                                                                        if(resultColumn.getReplaceExprAsIdentifiers()!=null && resultColumn.getReplaceExprAsIdentifiers().size()>0) {
                                                                                for(TReplaceExprAsIdentifier replace: resultColumn.getReplaceExprAsIdentifiers()) {
                                                                                        replaceAsIdentifierMap.put(replace.getIdentifier().toString(), new Pair<String, TExpression>(resultColumn.getExpr().getExceptReplaceClause().toString(), replace.getExpr()));
                                                                                        replaceColumnMap.put(replace.getIdentifier().toString(), replace.getIdentifier());
                                                                                }
                                                                                ResultSet resultSet = ((ResultColumn)modelObject).getResultSet();
                                                                                if(queryTable.isDetermined()) {
                                                                                        resultSet.getColumns().clear();
                                                                                }
                                                                        }
                                                                }
                                                                
                                                                int index = 0;
                                                                for (int j = 0; j < queryTable.getColumns().size(); j++) {
                                                                        ResultColumn targetColumn = queryTable.getColumns().get(j);
                                                                        if (exceptColumnList != null) {
                                                                                boolean flag = false;
                                                                                for (TObjectName objectName : exceptColumnList) {
                                                                                        if (DlineageUtil.sameColumnName(objectName, targetColumn.getName())) {
                                                                                                flag = true;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                                if (flag) {
                                                                                        continue;
                                                                                }
                                                                        }
                                                                        
                                                                        if (replaceAsIdentifierMap.containsKey(targetColumn.getName())) {
                                                                                Pair<String, TExpression> expr = replaceAsIdentifierMap.get(targetColumn.getName());
                                                                                ResultSet resultSet = ((ResultColumn)modelObject).getResultSet();
                                                                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSet, replaceColumnMap.get(targetColumn.getName()));
                                                                                Transform transform = new Transform();
                                                                                transform.setType(Transform.EXPRESSION);
                                                                                TObjectName expression = new TObjectName();
                                                                                expression.setString(expr.first);
                                                                        transform.setCode(expression);
                                                                                resultColumn.setTransform(transform);
                                                                                analyzeResultColumnExpressionRelation(resultColumn, expr.second);
                                                                        } else {
                                                                                if(!replaceAsIdentifierMap.isEmpty()) {
                                                                                        ResultSet resultSet = ((ResultColumn) modelObject).getResultSet();
                                                                                        TObjectName resultColumnName = new TObjectName();
                                                                                        resultColumnName.setString(targetColumn.getName());
                                                                                        ResultColumn resultColumn = modelFactory.createResultColumn(resultSet,
                                                                                                        resultColumnName);
                                                                                        DataFlowRelationship relation1 = modelFactory.createDataFlowRelation();
                                                                                        relation1.setEffectType(effectType);
                                                                                        relation1.setProcess(process);
                                                                                        relation1.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                        relation1.addSource(new ResultColumnRelationshipElement(targetColumn));
                                                                                }
                                                                                else {
                                                                                        relation.addSource(
                                                                                                new ResultColumnRelationshipElement(targetColumn));
                                                                                }
                                                                        }
                                                                        index++;
                                                                }
                                                        } else {
                                                                if (table.getCTE() != null) {
                                                                        
                                                                        if (modelObject instanceof TableColumn) {
                                                                                Table modelTable = ((TableColumn) modelObject).getTable();
                                                                                if (modelTable.getSubType() == SubType.unnest) {
                                                                                        boolean find = false;
                                                                                        for (k = 0; k < columns.size(); k++) {
                                                                                                ResultColumn column = columns.get(k);
                                                                                                if (column.isStruct()) {
                                                                                                        List<String> names = SQLUtil.parseNames(column.getName());
                                                                                                        for (String name : names) {
                                                                                                                if (DlineageUtil.sameColumnName(name, columnName)) {
                                                                                                                        DataFlowRelationship unnestRelation = modelFactory.createDataFlowRelation();
                                                                                                                        unnestRelation.setEffectType(effectType);
                                                                                                                        unnestRelation.setProcess(process);
                                                                                                                        unnestRelation.addSource(new ResultColumnRelationshipElement(
                                                                                                                                        column, columnName));
                                                                                                                        TObjectName unnestTableColumnName = new TObjectName();
                                                                                                                        unnestTableColumnName.setString(names.get(names.size()-1));
                                                                                                                        TableColumn unnestTableColumn = modelFactory.createTableColumn(modelTable, unnestTableColumnName, true);
                                                                                                                        unnestRelation.setTarget(new TableColumnRelationshipElement(unnestTableColumn));
                                                                                                                        find = true;
                                                                                                                }
                                                                                                        }
                                                                                                        List<String> names1 = SQLUtil.parseNames(column.getName());
                                                                                                        if (names.size() == 1 && names1.size() >= 1) {
                                                                                                                for (String name : names1) {
                                                                                                                        if (DlineageUtil.sameColumnName(name, column.getName())) {
                                                                                                                                DataFlowRelationship unnestRelation = modelFactory.createDataFlowRelation();
                                                                                                                                unnestRelation.setEffectType(effectType);
                                                                                                                                unnestRelation.setProcess(process);
                                                                                                                                unnestRelation.addSource(new ResultColumnRelationshipElement(
                                                                                                                                                column, columnName));
                                                                                                                                TObjectName unnestTableColumnName = new TObjectName();
                                                                                                                                unnestTableColumnName.setString(names1.get(names.size()-1));
                                                                                                                                TableColumn unnestTableColumn = modelFactory.createTableColumn(modelTable, unnestTableColumnName, true);
                                                                                                                                unnestRelation.setTarget(new TableColumnRelationshipElement(unnestTableColumn));
                                                                                                                                find = true;
                                                                                                                        }
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                        if (find) {
                                                                                                modelTable.getColumns().remove(modelObject);
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                        
                                                                        ColumnNameIndex nameIdx = getColumnNameIndex(columns);
                                                                        if (nameIdx.byIdentifier != null && DlineageUtil.columnKey(columnName) != null) {
                                                                                // Fast path: simple column list (no star/struct). A direct index lookup
                                                                                // reproduces the linear scan below for such lists: first-match-wins,
                                                                                // skip when the match IS modelObject, and stop at the first match.
                                                                                ResultColumn match = nameIdx.byIdentifier.get(DlineageUtil.columnKey(columnName));
                                                                                if (match != null && !match.equals(modelObject)) {
                                                                                        relation.addSource(
                                                                                                        new ResultColumnRelationshipElement(match, columnName));
                                                                                }
                                                                        } else {
                                                                        for (k = 0; k < columns.size(); k++) {
                                                                                ResultColumn column = columns.get(k);
                                                                                if (column.isStarColumn()) {
                                                                                        if (!containsStarColumn(column, columnName)) {
                                                                                                column.bindStarLinkColumn(columnName);
                                                                                        }
                                                                                        relation.addSource(new ResultColumnRelationshipElement(column, columnName));
                                                                                } else if (referencesColumn(columnName, column)) {
                                                                                        if (!column.equals(modelObject)) {
                                                                                                relation.addSource(
                                                                                                                new ResultColumnRelationshipElement(column, columnName));
                                                                                        }
                                                                                        break;
                                                                                } else if(column.isStruct()) {
                                                                                        List<String> names = SQLUtil.parseNames(column.getName());
                                                                                        for(String name: names) {
                                                                                                if (DlineageUtil.sameColumnName(name, columnName)) {
                                                                                                        relation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(column, columnName));
                                                                                                }
                                                                                        }
                                                                                        List<String> names1 = SQLUtil.parseNames(column.getName());
                                                                                        if (names.size() == 1 && names1.size() >= 1) {
                                                                                                for(String name: names1) {
                                                                                                        if (DlineageUtil.sameColumnName(name, column.getName())) {
                                                                                                                relation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(column, columnName));
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                        }
                                                                } else if ((table.getAliasClause() != null
                                                                                && table.getAliasClause().getColumns() != null)
                                                                                // a VALUES table without a column list has the vendor's names (Mantis 4823); a
                                                                                // vendor that names none has none to read, whatever the model calls them
                                                                                || (table.getTableType() == ETableSource.rowList
                                                                                                && TValueClause.defaultColumnName(option.getVendor(), 1) != null)) {
                                                                        boolean found = false;
                                                                        for (k = 0; k < columns.size(); k++) {
                                                                                ResultColumn column = columns.get(k);
                                                                                List<String> splits = SQLUtil.parseNames(columnName.toString());
                                                                                if (column.isStarColumn()) {
                                                                                        readThroughStar(column, columnName, relation);
                                                                                        found = true;
                                                                                } else if (splits.size() > 1 && EDbVendor.dbvbigquery == getOption().getVendor()) {
                                                                                        if (referencesColumnSegment(splits.get(0), column)) {
                                                                                                if (!column.equals(modelObject)) {
                                                                                                        relation.addSource(new ResultColumnRelationshipElement(column,
                                                                                                                        columnName));
                                                                                                }
                                                                                                found = true;
                                                                                                break;
                                                                                        }
                                                                                } else if (referencesColumn(columnName, column)) {
                                                                                        if (!column.equals(modelObject)) {
                                                                                                relation.addSource(
                                                                                                                new ResultColumnRelationshipElement(column, columnName));
                                                                                        }
                                                                                        found = true;
                                                                                        break;
                                                                                }
                                                                        }
                                                                        if (!found) {
                                                                                readPastAliasList(table, columnName, relation);
                                                                        }
                                                                } else if (table.getSubquery() != null || (table.getTableExpr() != null
                                                                                && table.getTableExpr().getSubQuery() != null)) {
                                                                        TSelectSqlStatement select = table.getSubquery();
                                                                        if (select == null) {
                                                                                select = table.getTableExpr().getSubQuery();
                                                                        }
                                                                        if (columnName.getSourceTable() != null) {
                                                                                Object tableModel = modelManager.getModel(columnName.getSourceTable());
                                                                                appendResultColumnRelationSource(modelObject, relation, columnIndex, columnName,
                                                                                                tableModel);
                                                                        } else if (columnName.getObjectToken() != null
                                                                                        && !SQLUtil.isEmpty(table.getAliasName())) {
                                                                                if (DlineageUtil.compareTableIdentifier(columnName.getObjectToken().toString(),
                                                                                                table.getAliasName())) {
                                                                                        Object tableModel = modelManager.getModel(table);
                                                                                        appendResultColumnRelationSource(modelObject, relation, columnIndex,
                                                                                                        columnName, tableModel);
                                                                                }
                                                                        } else if(columns!=null) {
                                                                                for (k = 0; k < columns.size(); k++) {
                                                                                        ResultColumn column = columns.get(k);
                                                                                        List<String> splits = SQLUtil.parseNames(columnName.toString());        
                                                                                        if (column.isStarColumn()) {
                                                                                                if (!containsStarColumn(column, columnName)) {
                                                                                                        column.bindStarLinkColumn(columnName);
                                                                                                }
                                                                                                relation.addSource(new ResultColumnRelationshipElement(column, columnName));
                                                                                        } else if (splits.size() > 1 && EDbVendor.dbvbigquery == getOption().getVendor()) {
                                                                                                if (referencesColumnSegment(splits.get(0), column)) {
                                                                                                        if (!column.equals(modelObject)) {
                                                                                                                relation.addSource(new ResultColumnRelationshipElement(column,
                                                                                                                                columnName));
                                                                                                        }
                                                                                                        break;
                                                                                                }
                                                                                        } else if (referencesColumn(columnName, column)) {
                                                                                                if (!column.equals(modelObject)) {
                                                                                                        relation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(column, columnName));
                                                                                                }
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                } else if (table.getOutputMerge() != null) {
                                                                        if (columnName.getSourceColumn() != null) {
                                                                                Object model = modelManager.getModel(columnName.getSourceColumn());
                                                                                if (model instanceof ResultColumn) {
                                                                                        ResultColumn resultColumn = (ResultColumn) model;
                                                                                        if (resultColumn.isStarColumn()
                                                                                                        && !containsStarColumn(resultColumn, columnName)) {
                                                                                                resultColumn.bindStarLinkColumn(columnName);
                                                                                        }
                                                                                        relation.addSource(
                                                                                                        new ResultColumnRelationshipElement(resultColumn, columnName));
                                                                                }
                                                                        } else if (columnName.getSourceTable() != null) {
                                                                                Object tableModel = modelManager.getModel(columnName.getSourceTable());
                                                                                appendResultColumnRelationSource(modelObject, relation, columnIndex, columnName,
                                                                                                tableModel);
                                                                        } else if (columnName.getObjectToken() != null
                                                                                        && !SQLUtil.isEmpty(table.getAliasName())) {
                                                                                if (DlineageUtil.compareTableIdentifier(columnName.getObjectToken().toString(),
                                                                                                table.getAliasName())) {
                                                                                        Object tableModel = modelManager.getModel(table);
                                                                                        appendResultColumnRelationSource(modelObject, relation, columnIndex,
                                                                                                        columnName, tableModel);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                        if (relation.getSources().size() == 0 && isKeyword(columnName)) {
                                Table constantTable = modelFactory.createConstantsTable(stmtStack.peek());
                                TableColumn constantColumn = modelFactory.createTableColumn(constantTable, columnName, true);
                                relation.addSource(new ConstantRelationshipElement(constantColumn));
                        }

                        addRelationRowsImpacts(relation, effectType);
                }
                } finally {
                        if (sqllrRefs != null) {
                                sqllrRefs.closeFrame(sqllrFrame);
                        }
                }
                return relation;
        }

        /**
         * The row lineage of {@code relation}'s sources: an fdr edge into its target's rows from the rows of each source
         * whose relation has row lineage of its own, as every column read publishes.
         */
        private void addRelationRowsImpacts(DataFlowRelationship relation, EffectType effectType) {
                if (relation.getSources().size() > 0) {
                        for (RelationshipElement<?> sourceItem: relation.getSources()) {
                                Object source = sourceItem.getElement();
                                ImpactRelationship impactRelation = null;
                                if (source instanceof ResultColumn
                                                && !((ResultColumn) source).getResultSet().getRelationRows().getHoldRelations().isEmpty()) {
                                        impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        ((ResultColumn) source).getResultSet().getRelationRows()));
                                        impactRelation.setEffectType(effectType);
                                } else if (source instanceof TableColumn
                                                && !((TableColumn) source).getTable().getRelationRows().getHoldRelations().isEmpty()) {
                                        impactRelation = modelFactory.createImpactRelation();
                                        impactRelation.addSource(new RelationRowsRelationshipElement<TableRelationRows>(
                                                        ((TableColumn) source).getTable().getRelationRows()));
                                        impactRelation.setEffectType(effectType);;
                                }

                                if (impactRelation == null) {
                                        continue;
                                }

                                if (relation.getTarget() != null) {
                                        Object target = relation.getTarget().getElement();
                                        if (target instanceof ResultColumn) {
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                ((ResultColumn) target).getResultSet().getRelationRows()));
                                        } else if (target instanceof TableColumn) {
                                                impactRelation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                                                ((TableColumn) target).getTable().getRelationRows()));
                                        }
                                }

                                if (impactRelation.getSources() != null && !impactRelation.getSources().isEmpty()
                                                && impactRelation.getTarget() != null
                                                && impactRelation.getSources().iterator().next().getElement() == impactRelation.getTarget().getElement()) {
                                        modelManager.removeRelation(impactRelation);
                                }
                        }
                }
        }

        private boolean isNotInProcedure(Table table) {
        TStoredProcedureSqlStatement stmt = getProcedureParent(stmtStack.peek());
                Procedure procedure = this.modelFactory.createProcedure(stmt);
                if(procedure!=null && procedure.getName().equals(table.getParent())){
                        return false;
                }
                return true;
        }

        private boolean hasJoin(TCustomSqlStatement stmt) {
                if (stmt.getJoins() == null || stmt.getJoins().size() == 0)
                        return false;
                if (stmt.getJoins().size() > 1) {
                        return true;
                }
                TJoinItemList joinItems = stmt.getJoins().getJoin(0).getJoinItems();
                if (joinItems == null || joinItems.size() == 0) {
                        return false;
                }
                return true;
        }

        private boolean isInQuery(TSelectSqlStatement query, TResultColumn column) {
                if(query == null)
                        return false;
                TResultColumnList columns = query.getResultColumnList();
                if (columns != null) {
                        for (int i = 0; i < columns.size(); i++) {
                                if (columns.getResultColumn(i).equals(column)) {
                                        return true;
                                }
                        }
                }
                return false;
        }

        private void appendResultColumnRelationSource(Object modelObject, DataFlowRelationship relation, int columnIndex,
                        TObjectName columnName, Object tableModel) {
                if (tableModel instanceof Table) {
                        Object model = modelManager.getModel(new Pair<Table, TObjectName>((Table) tableModel, columnName));
                        if (model instanceof TableColumn) {
                                relation.addSource(new TableColumnRelationshipElement((TableColumn) model));
                        }
                } else if (tableModel instanceof ResultSet) {
                        List<ResultColumn> queryColumns = ((ResultSet) tableModel).getColumns();
                        boolean flag = false;
                        for (int l = 0; l < queryColumns.size(); l++) {
                                ResultColumn column = queryColumns.get(l);
                                if (referencesColumn(columnName, column)) {
                                        if (!column.equals(modelObject)) {
                                                relation.addSource(new ResultColumnRelationshipElement(column, columnName));
                                                flag = true;
                                        }
                                        break;
                                }
                        }
                        if (!flag) {
                                for (int l = 0; l < queryColumns.size(); l++) {
                                        ResultColumn column = queryColumns.get(l);
                                        if (column.isStarColumn()) {
                                                if (!containsStarColumn(column, columnName)) {
                                                        column.bindStarLinkColumn(columnName);
                                                }
                                                relation.addSource(new ResultColumnRelationshipElement(column, columnName));
                                                flag = true;
                                                break;
                                        }
                                }
                        }
                        if (!flag && columnIndex < queryColumns.size() && columnIndex != -1
                                        && (DlineageUtil.isWildcard(columnName)
                                                        || queryColumns.get(columnIndex).getIdentifierKey() == null)) {
                                relation.addSource(new ResultColumnRelationshipElement(queryColumns.get(columnIndex), columnName));
                        }
                }
        }

        private boolean isApplyJoin(TCustomSqlStatement stmt) {
                if (stmt.getJoins() == null || stmt.getJoins().size() == 0)
                        return false;
                TJoinItemList joinItems = stmt.getJoins().getJoin(0).getJoinItems();
                if (joinItems == null || joinItems.size() == 0) {
                        return false;
                }
                if (joinItems.getJoinItem(0).getJoinType() == EJoinType.crossapply
                                || joinItems.getJoinItem(0).getJoinType() == EJoinType.outerapply)
                        return true;
                return false;
        }

        private boolean containsStarColumn(ResultColumn resultColumn, TObjectName columnName) {
                return resultColumn.containsStarLinkColumn(columnName);
        }

        private void analyzeAggregate(TFunctionCall function, TExpression expr) {
                // SQL-LR: a nested analysis never inherits the reference of the loop that called it
                SqllrObservations sqllr = modelManager.getSqllrObservations();
                int sqllrBarrier = sqllr == null ? -1 : sqllr.openFrame();
                try {
                        analyzeAggregateInSqllrBarrier(function, expr);
                } finally {
                        if (sqllr != null) {
                                sqllr.closeFrame(sqllrBarrier);
                        }
                }
        }

        private void analyzeAggregateInSqllrBarrier(TFunctionCall function, TExpression expr) {
                TCustomSqlStatement stmt = stmtStack.peek();
                ResultSet resultSet = (ResultSet) modelManager.getModel(stmt.getResultColumnList());
                if (resultSet == null) {
                        return;
                }

                if (expr != null) {
                        columnsInExpr visitor = new columnsInExpr();
                        expr.inOrderTraverse(visitor);
                        List<TObjectName> objectNames = visitor.getObjectNames();
                        SqllrObservations sqllrRefs = modelManager.getSqllrObservations();
                        int sqllrFrame = sqllrRefs == null ? -1 : sqllrRefs.openFrame();
                        try { // SQL-LR: each element added in this loop is recorded with the reference of its iteration
                        for (int j = 0; j < objectNames.size(); j++) {
                                TObjectName columnName = objectNames.get(j);
                                if (sqllrRefs != null) {
                                        sqllrRefs.reference(sqllrFrame, columnName);
                                }

                                if (columnName.getDbObjectType() == EDbObjectType.variable) {
                                        continue;
                                }

                                if (columnName.getColumnNameOnly().startsWith("@")
                                                && (option.getVendor() == EDbVendor.dbvmssql || option.getVendor() == EDbVendor.dbvazuresql)) {
                                        continue;
                                }

                                if (columnName.getColumnNameOnly().startsWith(":")
                                                && (option.getVendor() == EDbVendor.dbvhana || option.getVendor() == EDbVendor.dbvteradata)) {
                                        continue;
                                }

                                Object targetModel0 = modelManager.getModel(function.getFunctionName());
                                if (targetModel0 == null && function.getFunctionType() == EFunctionType.array_agg_t && modelManager.getModel(function) instanceof Function) {
                                        Function functionModel = (Function) modelManager.getModel(function);
                                        if (functionModel.getColumns().size() == 1) {
                                                targetModel0 = ((Function) functionModel).getColumns().get(0);
                                        }
                                }
                                if (!(targetModel0 instanceof ResultColumn)) {
                                        continue;
                                }
                                ResultColumn targetResultColumn0 = (ResultColumn) targetModel0;
                                AbstractRelationship relation = modelFactory.createRecordSetRelation();
                                relation.setEffectType(EffectType.function);
                                relation.setFunction(function.getFunctionName().toString());
                                relation.setTarget(new ResultColumnRelationshipElement(targetResultColumn0));
                                TTable table = structFieldReadTable(modelManager.getTable(stmt, columnName), columnName, stmt.tables);
                                if (table != null) {
                                        if (modelManager.getModel(table) instanceof Table) {
                                                Table tableModel = (Table) modelManager.getModel(table);
                                                if (tableModel != null) {
                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel, columnName, false);
                                                        if (columnModel != null) {
                                                                relation.addSource(
                                                                                new TableColumnRelationshipElement(columnModel, columnName.getLocation(),
                                                                                                columnName));
                                                        }
                                                }
                                        } else if (modelManager.getModel(table) instanceof QueryTable) {
                                                Object model = modelManager.getModel(columnName.getSourceColumn());
                                                if (!(model instanceof ResultColumn)) {
                                                        model = structFieldReadSource(structFieldReadBaseColumn(columnName,
                                                                        ((QueryTable) modelManager.getModel(table)).getColumns()), columnName);
                                                }
                                                if (model instanceof ResultColumn) {
                                                        ResultColumn resultColumn = (ResultColumn) model;
                                                        if (resultColumn != null) {
                                                                relation.addSource(
                                                                                new ResultColumnRelationshipElement(resultColumn, columnName.getLocation(), columnName));
                                                        }
                                                }
                                        } else if (functionOutputColumn(modelManager.getModel(table)) != null) {
                                                // A table function's column is read through its output column, as the select list reads it
                                                // (Mantis 4797).
                                                relation.addSource(new ResultColumnRelationshipElement(
                                                                functionOutputColumn(modelManager.getModel(table)), columnName.getLocation(), columnName));
                                        }
                                }
                        }
                        } finally {
                                if (sqllrRefs != null) {
                                        sqllrRefs.closeFrame(sqllrFrame);
                                }
                        }

                        List<TParseTreeNode> functions = visitor.getFunctions();
                        for (int j = 0; j < functions.size(); j++) {
                                TParseTreeNode functionObj = functions.get(j);
                                Object functionModel = modelManager.getModel(functionObj);
                                if (functionModel == null) {
                                        functionModel = createFunction(functionObj);
                                }
                                if (functionModel instanceof Function) {
                                        Object targetModel1 = modelManager.getModel(function.getFunctionName());
                                        if (targetModel1 == null && function.getFunctionType() == EFunctionType.array_agg_t && modelManager.getModel(function) instanceof Function) {
                                                Function functionModel1 = (Function) modelManager.getModel(function);
                                                if (functionModel1.getColumns().size() == 1) {
                                                        targetModel1 = ((Function) functionModel1).getColumns().get(0);
                                                }
                                        }
                                        if (!(targetModel1 instanceof ResultColumn)) {
                                                continue;
                                        }
                                        ResultColumn targetRC_func = (ResultColumn) targetModel1;
                                        AbstractRelationship relation;
                                        if ("COUNT".equalsIgnoreCase(builtInFunctionName(function))) { // non-identifier-compare: built-in function name
                                                // relation = modelFactory.createDataFlowRelation();
                                                relation = modelFactory.createRecordSetRelation();
                                        } else {
                                                relation = modelFactory.createRecordSetRelation();
                                        }
                                        relation.setEffectType(EffectType.function);
                                        relation.setFunction(function.getFunctionName().toString());
                                        relation.setTarget(new ResultColumnRelationshipElement(targetRC_func));

                                        if (functionObj instanceof TFunctionCall) {
                                                ResultColumn resultColumn = (ResultColumn) modelManager
                                                                .getModel(((TFunctionCall) functionObj).getFunctionName());
                                                if (resultColumn != null) {
                                                        ResultColumnRelationshipElement element = new ResultColumnRelationshipElement(resultColumn,
                                                                        ((TFunctionCall) functionObj).getFunctionName().getLocation());
                                                        relation.addSource(element);
                                                }
                                        }
                                        if (functionObj instanceof TCaseExpression) {
                                                ResultColumn resultColumn = (ResultColumn) modelManager
                                                                .getModel(((TCaseExpression) functionObj).getWhenClauseItemList());
                                                if (resultColumn != null) {
                                                        ResultColumnRelationshipElement element = new ResultColumnRelationshipElement(resultColumn);
                                                        relation.addSource(element);
                                                }
                                        }
                                } else if (functionModel instanceof Table) {
                                        Object targetModel2 = modelManager.getModel(function.getFunctionName());
                                        if (targetModel2 == null && function.getFunctionType() == EFunctionType.array_agg_t && modelManager.getModel(function) instanceof Function) {
                                                Function functionModel1 = (Function) modelManager.getModel(function);
                                                if (functionModel1.getColumns().size() == 1) {
                                                        targetModel2 = ((Function) functionModel1).getColumns().get(0);
                                                }
                                        }
                                        if (!(targetModel2 instanceof ResultColumn)) {
                                                continue;
                                        }
                                        ResultColumn targetRC_table = (ResultColumn) targetModel2;
                                        TableColumn tableColumn = modelFactory.createTableColumn((Table) functionModel,
                                                        function.getFunctionName(), false);
                                        AbstractRelationship relation;
                                        if ("COUNT".equalsIgnoreCase(builtInFunctionName(function))) { // non-identifier-compare: built-in function name
                                                // relation = modelFactory.createDataFlowRelation();
                                                relation = modelFactory.createRecordSetRelation();
                                        } else {
                                                relation = modelFactory.createRecordSetRelation();
                                        }
                                        relation.setEffectType(EffectType.function);
                                        relation.setFunction(function.getFunctionName().toString());
                                        relation.setTarget(new ResultColumnRelationshipElement(targetRC_table));
                                        TableColumnRelationshipElement element = new TableColumnRelationshipElement(tableColumn);
                                        relation.addSource(element);
                                }
                        }
                }

                if (expr == null || "COUNT".equalsIgnoreCase(builtInFunctionName(function))) { // non-identifier-compare: built-in function name
                        if ("COUNT".equalsIgnoreCase(builtInFunctionName(function)) // non-identifier-compare: built-in function name
                                        // https://e.gitee.com/gudusoft/issues/list?issue=I4L5EO
                                        // 对于非 count() 函数，当有group by clause时， RelationRows 不参与indirect dataflow,
                                        // 让位与group by clause中的column.
                                        || ((TSelectSqlStatement) stmt).getGroupByClause() == null) {
                                TTableList tables = stmt.getTables();
                                if (tables != null) {
                                        for (int i = 0; i < tables.size(); i++) {
                                                TTable table = tables.getTable(i);
                                                if (modelManager.getModel(table) == null && table.getSubquery() == null) {
                                                        modelFactory.createTable(table);
                                                }
                                                if (modelManager.getModel(table) instanceof Table) {
                                                        Object targetModel3 = modelManager.getModel(function.getFunctionName());
                                                        if (targetModel3 == null && function.getFunctionType() == EFunctionType.array_agg_t && modelManager.getModel(function) instanceof Function) {
                                                                Function functionModel = (Function) modelManager.getModel(function);
                                                                if (functionModel.getColumns().size() == 1) {
                                                                        targetModel3 = functionModel.getColumns().get(0);
                                                                }
                                                        }
                                                        if (!(targetModel3 instanceof ResultColumn)) {
                                                                continue;
                                                        }
                                                        ResultColumn targetRC_tbl = (ResultColumn) targetModel3;
                                                        Table tableModel = (Table) modelManager.getModel(table);
                                                        AbstractRelationship relation;
                                                        if ("COUNT".equalsIgnoreCase(builtInFunctionName(function))) { // non-identifier-compare: built-in function name
                                                                // relation = modelFactory.createDataFlowRelation();
                                                                relation = modelFactory.createRecordSetRelation();
                                                        } else {
                                                                relation = modelFactory.createRecordSetRelation();
                                                        }
                                                        relation.setEffectType(EffectType.function);
                                                        relation.setFunction(function.getFunctionName().toString());
                                                        relation.setTarget(new ResultColumnRelationshipElement(targetRC_tbl));

                                                        if (relation instanceof DataFlowRelationship && option.isShowCountTableColumn()) {
                                                                List<TExpression> expressions = new ArrayList<TExpression>();
                                                                getFunctionExpressions(expressions, new ArrayList<TExpression>(), function);
                                                                for (int j = 0; j < expressions.size(); j++) {
                                                                        columnsInExpr visitor = new columnsInExpr();
                                                                        expressions.get(j).inOrderTraverse(visitor);
                                                                        List<TObjectName> objectNames = visitor.getObjectNames();
                                                                        if (objectNames != null) {
                                                                                for (TObjectName columnName : objectNames) {
                                                                                        TTable tempTable = modelManager.getTable(stmt, columnName);
                                                                                        if (table.equals(tempTable)) {
                                                                                                TableColumn tableColumn = modelFactory.createTableColumn(tableModel,
                                                                                                                columnName, false);
                                                                                                TableColumnRelationshipElement element = new TableColumnRelationshipElement(
                                                                                                                tableColumn);
                                                                                                relation.addSource(element);
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                        if (relation.getSources().size() == 0) {
                                                                RelationRowsRelationshipElement element = new RelationRowsRelationshipElement<TableRelationRows>(
                                                                                tableModel.getRelationRows());
                                                                relation.addSource(element);
                                                        }
                                                } else if (modelManager.getModel(table) instanceof QueryTable) {
                                                        Object targetModel4 = modelManager.getModel(function.getFunctionName());
                                                        if (targetModel4 == null && function.getFunctionType() == EFunctionType.array_agg_t && modelManager.getModel(function) instanceof Function) {
                                                                Function functionModel = (Function) modelManager.getModel(function);
                                                                targetModel4 = functionModel.getColumns().get(0);
                                                        }
                                                        if (!(targetModel4 instanceof ResultColumn)) {
                                                                continue;
                                                        }
                                                        ResultColumn targetRC_qt = (ResultColumn) targetModel4;
                                                        QueryTable tableModel = (QueryTable) modelManager.getModel(table);
                                                        AbstractRelationship relation;
                                                        if ("COUNT".equalsIgnoreCase(builtInFunctionName(function))) { // non-identifier-compare: built-in function name
                                                                // relation = modelFactory.createDataFlowRelation();
                                                                relation = modelFactory.createRecordSetRelation();
                                                        } else {
                                                                relation = modelFactory.createRecordSetRelation();
                                                        }
                                                        relation.setEffectType(EffectType.function);
                                                        relation.setFunction(function.getFunctionName().toString());
                                                        relation.setTarget(new ResultColumnRelationshipElement(targetRC_qt));
                                                        RelationRowsRelationshipElement element = new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                        tableModel.getRelationRows());
                                                        relation.addSource(element);
                                                } else if (functionOutputColumn(modelManager.getModel(table)) != null) {
                                                        // a table function: its rows filter the count as a table's rows do (Mantis 4815)
                                                        Object targetModel5 = modelManager.getModel(function.getFunctionName());
                                                        if (targetModel5 == null && function.getFunctionType() == EFunctionType.array_agg_t && modelManager.getModel(function) instanceof Function) {
                                                                Function functionModel = (Function) modelManager.getModel(function);
                                                                targetModel5 = functionModel.getColumns().get(0);
                                                        }
                                                        if (!(targetModel5 instanceof ResultColumn)) {
                                                                continue;
                                                        }
                                                        ResultSet functionModel = functionOutputColumn(modelManager.getModel(table)).getResultSet();
                                                        AbstractRelationship relation = modelFactory.createRecordSetRelation();
                                                        relation.setEffectType(EffectType.function);
                                                        relation.setFunction(function.getFunctionName().toString());
                                                        relation.setTarget(new ResultColumnRelationshipElement((ResultColumn) targetModel5));
                                                        relation.addSource(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                                        functionModel.getRelationRows()));
                                                }
                                        }
                                }
                        }

                        if (stmt.getWhereClause() == null || stmt.getWhereClause().getCondition() == null) {
                                return;
                        }

                        columnsInExpr visitor = new columnsInExpr();
                        stmt.getWhereClause().getCondition().inOrderTraverse(visitor);
                        List<TObjectName> objectNames = visitor.getObjectNames();
                        SqllrObservations sqllrRefs = modelManager.getSqllrObservations();
                        int sqllrFrame = sqllrRefs == null ? -1 : sqllrRefs.openFrame();
                        try { // SQL-LR: each element added in this loop is recorded with the reference of its iteration
                        for (int j = 0; j < objectNames.size(); j++) {
                                TObjectName columnName = objectNames.get(j);
                                if (sqllrRefs != null) {
                                        sqllrRefs.reference(sqllrFrame, columnName);
                                }
                                if (columnName.getDbObjectType() == EDbObjectType.variable) {
                                        Variable tableModel;
                                        if (columnName.toString().indexOf(".") != -1) {
                                                List<String> splits = SQLUtil.parseNames(columnName.toString());
                                                tableModel = modelFactory.createReferencedVariable(splits.get(splits.size() - 2), true);
                                        } else {
                                                tableModel = modelFactory.createReferencedVariable(columnName);
                                        }
                                        tableModel.setCreateTable(true);
                                        tableModel.setSubType(SubType.record);
                                        TObjectName variableProperties = DlineageUtil.syntheticStarName();
                                        modelFactory.createTableColumn(tableModel, variableProperties, true);
                                }

//                              if (columnName.getColumnNameOnly().startsWith("@")
//                                              && (option.getVendor() == EDbVendor.dbvmssql || option.getVendor() == EDbVendor.dbvazuresql)) {
//                                      continue;
//                              }
//
//                              if (columnName.getColumnNameOnly().startsWith(":") && (option.getVendor() == EDbVendor.dbvhana || option.getVendor() == EDbVendor.dbvteradata)) {
//                                      continue;
//                              }

                                Object targetModel5 = modelManager.getModel(function.getFunctionName());
                                if (targetModel5 == null && function.getFunctionType() == EFunctionType.array_agg_t && modelManager.getModel(function) instanceof Function) {
                                        Function functionModel = (Function) modelManager.getModel(function);
                                        if (functionModel.getColumns().size() == 1) {
                                                targetModel5 = functionModel.getColumns().get(0);
                                        }
                                }
                                if (!(targetModel5 instanceof ResultColumn)) {
                                        continue;
                                }
                                AbstractRelationship relation = modelFactory.createRecordSetRelation();
                                relation.setEffectType(EffectType.function);
                                relation.setFunction(function.getFunctionName().toString());
                                relation.setTarget(new ResultColumnRelationshipElement((ResultColumn) targetModel5));

                                TTable table = structFieldReadTable(modelManager.getTable(stmt, columnName), columnName, stmt.tables);
                                if (table != null) {
                                        if (modelManager.getModel(table) instanceof Table) {
                                                Table tableModel = (Table) modelManager.getModel(table);
                                                if (tableModel != null) {
                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel, columnName, false);
                                                        if(columnModel == null) {
                                                                continue;
                                                        }
                                                        relation.addSource(
                                                                        new TableColumnRelationshipElement(columnModel, columnName.getLocation(),
                                                                                        columnName));
                                                }
                                        } else if (modelManager.getModel(table) instanceof QueryTable) {
                                                Object model = modelManager.getModel(columnName.getSourceColumn());
                                                if (!(model instanceof ResultColumn)) {
                                                        model = structFieldReadSource(structFieldReadBaseColumn(columnName,
                                                                        ((QueryTable) modelManager.getModel(table)).getColumns()), columnName);
                                                }
                                                if (model instanceof ResultColumn) {
                                                        ResultColumn resultColumn = (ResultColumn) model;
                                                        if (resultColumn != null) {
                                                                relation.addSource(
                                                                                new ResultColumnRelationshipElement(resultColumn, columnName.getLocation(), columnName));
                                                        }
                                                }
                                        } else if (functionOutputColumn(modelManager.getModel(table)) != null) {
                                                // A table function's column is read through its output column, as the select list reads it
                                                // (Mantis 4797).
                                                relation.addSource(new ResultColumnRelationshipElement(
                                                                functionOutputColumn(modelManager.getModel(table)), columnName.getLocation(), columnName));
                                        }
                                }
                        }
                        } finally {
                                if (sqllrRefs != null) {
                                        sqllrRefs.closeFrame(sqllrFrame);
                                }
                        }
                }
        }

        /**
         * The column a table function's rows are read through: the one output column of the {@link Function} model a
         * table function becomes, which the select list maps the function table's columns to. Null for any other model.
         */
        private static ResultColumn functionOutputColumn(Object model) {
                if (!(model instanceof Function)) {
                        return null;
                }
                List<ResultColumn> columns = ((Function) model).getColumns();
                return (columns == null || columns.isEmpty()) ? null : columns.get(0);
        }

        /** @return the impact relation made for the condition, {@code null} when there is none */
        /**
         * The clause a column operand of a WHERE, ON or HAVING filter carries ({@code columnName.getLocation()}: where,
         * joinCondition, having), for the filter's function, CASE and table-function operands, which have no clause of
         * their own: a function name's location is {@code unknown}, and a CASE had none (Mantis 4865). Null for a condition
         * analyzed without a clause (IF, a CASE in a select list, MERGE WHEN), whose operands are left as they are.
         */
        private static ESqlClause filterOperandClause(JoinClauseType joinClauseType) {
                if (joinClauseType == null) {
                        return null;
                }
                switch (joinClauseType) {
                case where:
                        return ESqlClause.where;
                case on:
                        return ESqlClause.joinCondition;
                case having:
                        return ESqlClause.having;
                default:
                        return null;
                }
        }

        private ImpactRelationship analyzeFilterCondition(Object modelObject, TExpression expr, EJoinType joinType,
                        JoinClauseType joinClauseType, EffectType effectType) {
                // SQL-LR: a nested analysis never inherits the reference of the loop that called it
                SqllrObservations sqllr = modelManager.getSqllrObservations();
                int sqllrBarrier = sqllr == null ? -1 : sqllr.openFrame();
                try {
                        return analyzeFilterConditionInSqllrBarrier(modelObject, expr, joinType, joinClauseType, effectType);
                } finally {
                        if (sqllr != null) {
                                sqllr.closeFrame(sqllrBarrier);
                        }
                }
        }

        private ImpactRelationship analyzeFilterConditionInSqllrBarrier(Object modelObject, TExpression expr, EJoinType joinType,
                        JoinClauseType joinClauseType, EffectType effectType) {
                if (expr == null) {
                        return null;
                }

                TCustomSqlStatement stmt = stmtStack.peek();

                columnsInExpr visitor = new columnsInExpr();
                expr.inOrderTraverse(visitor);

                List<TObjectName> objectNames = visitor.getObjectNames();
                List<TParseTreeNode> functions = visitor.getFunctions();
                List<TResultColumn> resultColumns = visitor.getResultColumns();
                List<TParseTreeNode> constants = visitor.getConstants();

                ImpactRelationship relation = modelFactory.createImpactRelation();
                relation.setEffectType(effectType);
                relation.setJoinClauseType(joinClauseType);
                if (modelObject instanceof ResultColumn) {
                        relation.setTarget(new ResultColumnRelationshipElement((ResultColumn) modelObject));
                } else if (modelObject instanceof Table) {
                        Table targetTable = (Table) modelObject;
                        relation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(
                                        targetTable.getRelationRows()));
                } else if (modelObject instanceof ResultSet) {
                        ResultSet targetResultSet = (ResultSet) modelObject;
                        relation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                        targetResultSet.getRelationRows()));
                } else {
                        ResultSet resultSet = (ResultSet) modelManager.getModel(stmt.getResultColumnList());
                        if (resultSet == null && stmt instanceof TUpdateSqlStatement) {
                                resultSet = (ResultSet) modelManager.getModel(stmt);
                        }
                        if (resultSet == null && stmt instanceof TMergeSqlStatement) {
                                TSelectSqlStatement subquery = ((TMergeSqlStatement) stmt).getUsingTable().getSubquery();
                                if (subquery != null) {
                                        resultSet = (ResultSet) modelManager.getModel(((TMergeSqlStatement) stmt).getUsingTable());
                                }
                                else {
                                        resultSet = modelFactory.createQueryTable(((TMergeSqlStatement) stmt).getUsingTable());
                                }
                        }
                        if (resultSet != null) {
                                relation.setTarget(
                                                new RelationRowsRelationshipElement<ResultSetRelationRows>(resultSet.getRelationRows()));
                        }
                        if (stmt instanceof TDeleteSqlStatement) {
                                Object deleteTarget = modelManager.getModel(((TDeleteSqlStatement) stmt).getTargetTable());
                                if (deleteTarget instanceof Table) {
                                        Table table = (Table) deleteTarget;
                                        relation.setTarget(new RelationRowsRelationshipElement<TableRelationRows>(table.getRelationRows()));
                                } else if (deleteTarget instanceof ResultSet) {
                                        ResultSet resultSetTarget = (ResultSet) deleteTarget;
                                        relation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        resultSetTarget.getRelationRows()));
                                }
                        }
                }
                if (relation.getTarget() != null) {

                        if (constants != null && constants.size() > 0) {
                                if (option.isShowConstantTable()) {
                                        Table constantTable = modelFactory.createConstantsTable(stmtStack.peek());
                                        for (int i = 0; i < constants.size(); i++) {
                                                TParseTreeNode constant = constants.get(i);
                                                if (constant instanceof TConstant) {
                                                        TableColumn constantColumn = modelFactory.createTableColumn(constantTable,
                                                                        (TConstant) constant);
                                                        relation.addSource(new ConstantRelationshipElement(constantColumn));
                                                } else if (constant instanceof TObjectName) {
                                                        TableColumn constantColumn = modelFactory.createTableColumn(constantTable,
                                                                        (TObjectName) constant, false);
                                                        if(constantColumn == null) {
                                                                continue;
                                                        }
                                                        relation.addSource(new ConstantRelationshipElement(constantColumn));
                                                }
                                        }
                                }
                        }

                        SqllrObservations sqllrRefs = modelManager.getSqllrObservations();
                        int sqllrFrame = sqllrRefs == null ? -1 : sqllrRefs.openFrame(modelObject);
                        try { // SQL-LR: each element added in this loop is recorded with the reference of its iteration
                        for (int j = 0; j < objectNames.size(); j++) {
                                TObjectName columnName = objectNames.get(j);
                                if (sqllrRefs != null) {
                                        sqllrRefs.reference(sqllrFrame, columnName);
                                }
                                ResultColumn boundAlias = getBoundAliasColumn(columnName, modelObject);
                                if (boundAlias != null) {
                                        relation.addSource(new ResultColumnRelationshipElement(boundAlias));
                                        continue;
                                }
                                if (columnName.getDbObjectType() == EDbObjectType.variable) {
                                        Variable variable = modelFactory.createReferencedVariable(columnName);
                                        variable.setSubType(SubType.record);
                                        if (variable.getColumns().isEmpty()) {
                                                TObjectName variableProperties = DlineageUtil.syntheticStarName();
                                                modelFactory.createTableColumn(variable, variableProperties, true);
                                        }
                                        relation.addSource(new TableColumnRelationshipElement(variable.getColumns().get(0),
                                                        columnName.getLocation(), columnName));
                                        continue;
                                }

                                if (columnName.getColumnNameOnly().startsWith("@")
                                                && (option.getVendor() == EDbVendor.dbvmssql || option.getVendor() == EDbVendor.dbvazuresql)) {
                                        continue;
                                }

                                if (columnName.getColumnNameOnly().startsWith(":")
                                                && (option.getVendor() == EDbVendor.dbvhana || option.getVendor() == EDbVendor.dbvteradata)) {
                                        continue;
                                }

                                TTable table = modelManager.getTable(stmt, columnName);

                                if (table == null) {
                                        table = columnName.getSourceTable();
                                }

                                if (table == null && stmt.tables != null) {
                                        for (int k = 0; k < stmt.tables.size(); k++) {
                                                if (table != null)
                                                        break;

                                                TTable tTable = stmt.tables.getTable(k);
                                                if (tTable.getTableType().name().startsWith("open")) {
                                                        continue;
                                                } else if (getTableLinkedColumns(tTable) != null && getTableLinkedColumns(tTable).size() > 0) {
                                                        for (int z = 0; z < getTableLinkedColumns(tTable).size(); z++) {
                                                                TObjectName refer = getTableLinkedColumns(tTable).getObjectName(z);
                                                                if (DlineageUtil.isStarName((refer)))
                                                                        continue;
                                                                if (DlineageUtil.sameColumnName(refer, columnName)) {
                                                                        table = tTable;
                                                                        break;
                                                                }
                                                        }
                                                } else if (columnName.getTableToken() != null
                                                                && (SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotTable, columnName.getTableToken().getAstext(), tTable.getName())
                                                                                || SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotTable, columnName.getTableToken().getAstext(), tTable.getAliasName()))) {
                                                        table = tTable;
                                                        break;
                                                }
                                        }

                                        if (table == null) {
                                                for (int k = 0; k < stmt.tables.size(); k++) {
                                                        if (table != null)
                                                                break;

                                                        TTable tTable = stmt.tables.getTable(k);
                                                        Object model = ModelBindingManager.get().getModel(tTable);
                                                        if (model instanceof Table) {
                                                                Table tableModel = (Table) model;
                                                                for (int z = 0; tableModel.getColumns() != null
                                                                                && z < tableModel.getColumns().size(); z++) {
                                                                        TableColumn refer = tableModel.getColumns().get(z);
                                                                        if (DlineageUtil.sameColumnName(refer.getName(), columnName)) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                        if (refer.hasStarLinkColumn()) {
                                                                                for (TObjectName linkColumn : refer.getStarLinkColumnList()) {
                                                                                        if (DlineageUtil.sameColumnName(linkColumn, columnName)) {
                                                                                                table = tTable;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        } else if (model instanceof QueryTable) {
                                                                QueryTable tableModel = (QueryTable) model;
                                                                for (int z = 0; tableModel.getColumns() != null
                                                                                && z < tableModel.getColumns().size(); z++) {
                                                                        ResultColumn refer = tableModel.getColumns().get(z);
                                                                        if (DlineageUtil.columnMatches(refer, columnName)) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                        if (refer.hasStarLinkColumn()) {
                                                                                for (TObjectName linkColumn : refer.getStarLinkColumnList()) {
                                                                                        if (DlineageUtil.sameColumnName(linkColumn, columnName)) {
                                                                                                table = tTable;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }

                                // STRUCT tree, as in a select list: a field read TSQLResolver2 could not place belongs to the one relation
                                // that declares its base column, and a field read that several relations could own has no proven owner
                                // (plan rule R3)
                                table = structFieldReadTable(table, columnName, stmt.tables);

                                if (table == null && stmt.tables != null && stmt.tables.size() != 0
                                                && !(isBuiltInFunctionName(columnName) && isFromFunction(columnName))) {

                                        if (modelManager.getModel(stmt) instanceof ResultSet) {
                                                ResultSet resultSetModel = (ResultSet) modelManager.getModel(stmt);
                                                boolean find = false;
                                                for (ResultColumn resultColumn : resultSetModel.getColumns()) {
                                                        if(resultColumn.equals(modelObject)) {
                                                                continue;
                                                        }
                                                        if (!TSQLEnv.isAliasReferenceForbidden.get(option.getVendor())) {
                                                                if (isAliasReference(columnName, resultColumn)) {
                                                                        if (resultColumn.getColumnObject() != null) {
                                                                                int startToken = resultColumn.getColumnObject().getStartToken().posinlist;
                                                                                int endToken = resultColumn.getColumnObject().getEndToken().posinlist;
                                                                                if (columnName.getStartToken().posinlist >= startToken
                                                                                                && columnName.getEndToken().posinlist <= endToken) {
                                                                                        continue;
                                                                                }
                                                                        }
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        find = true;
                                                                        break;
                                                                }
                                                        }
                                                }
                                                if (find) {
                                                        continue;
                                                }
                                        }

                                        TObjectName pseudoTableName = new TObjectName();
                                        // Use qualified prefix from column name if available (e.g., sch.pk_constv2 from sch.pk_constv2.c_cdsl)
                                        // Otherwise fall back to default pseudo table name
                                        String qualifiedPrefix = getQualifiedPrefixFromColumn(columnName);
                                        pseudoTableName.setString(qualifiedPrefix != null ? qualifiedPrefix : "pseudo_table_include_orphan_column");
                                        Table pseudoTable = modelFactory.createTableByName(pseudoTableName);
                                        pseudoTable.setPseudo(true);
                                        TableColumn pseudoTableColumn = modelFactory.createTableColumn(pseudoTable, columnName, true);

                                        // If not linking to first table and column has qualified prefix (3-part name like sch.pkg.col),
                                        // add the pseudo table column as source
                                        if (!isLinkOrphanColumnToFirstTable() && pseudoTableColumn != null && qualifiedPrefix != null) {
                                                SqllrObservations decided = SqllrObservations.current();
                                                if (decided != null) {
                                                        decided.decision(SqllrObservations.DECISION_ORPHAN_PSEUDO_TABLE, columnName, pseudoTable,
                                                                        "an orphan column with a qualified prefix");
                                                }
                                                relation.addSource(new TableColumnRelationshipElement(pseudoTableColumn));
                                        }

                                        if (isLinkOrphanColumnToFirstTable()) {
                                                TTable orphanTable = stmt.tables.getTable(0);
                                                SqllrObservations decided = SqllrObservations.current();
                                                if (decided != null) {
                                                        decided.decision(SqllrObservations.DECISION_ORPHAN_FIRST_TABLE, columnName, orphanTable,
                                                                        "linkOrphanColumnToFirstTable");
                                                }
                                                table = stmt.tables.getTable(0);
                                                Object tableModel = modelManager.getModel(table);
                                                if (tableModel == null) {
                                                        tableModel = modelFactory.createTable(orphanTable);
                                                }
                                                if (tableModel instanceof Table) {
                                                        modelFactory.createTableColumn((Table) tableModel, columnName, false);
                                                        ErrorInfo errorInfo = new ErrorInfo();
                                                        errorInfo.setErrorType(ErrorInfo.LINK_ORPHAN_COLUMN);
                                                        errorInfo.setErrorMessage("Link orphan column [" + columnName.toString()
                                                                        + "] to the first table [" + orphanTable.getFullNameWithAliasString() + "]");
                                                        errorInfo.setStartPosition(new Pair3<Long, Long, String>(columnName.getStartToken().lineNo,
                                                                        columnName.getStartToken().columnNo, ModelBindingManager.getGlobalHash()));
                                                        errorInfo.setEndPosition(new Pair3<Long, Long, String>(columnName.getEndToken().lineNo,
                                                                        columnName.getEndToken().columnNo + columnName.getEndToken().getAstext().length(),
                                                                        ModelBindingManager.getGlobalHash()));
                                                        errorInfo.fillInfo(this);
                                                        errorInfos.add(errorInfo);
                                                }
                                        }
                                }

                                if (table != null) {
                                        if (modelManager.getModel(table) instanceof Table) {
                                                Table tableModel = (Table) modelManager.getModel(table);
                                                if (tableModel != null) {
                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel, columnName, false);
                                                        if(columnModel!=null) {
                                                                // Carry the operand's own reference site: for created
                                                                // (e.g. #temp) tables the column model is shared with
                                                                // the definition site, whose coordinate is not where
                                                                // this ON/WHERE operand sits.
                                                                TableColumnRelationshipElement element = new TableColumnRelationshipElement(columnModel,
                                                                                columnName.getLocation(), columnName);
                                                                relation.addSource(element);
                                                        }
                                                }
                                        } else if (modelManager.getModel(table) instanceof QueryTable) {
                                                QueryTable tableModel = (QueryTable)modelManager.getModel(table);
                                                if (table.getSubquery() != null && table.getSubquery().isCombinedQuery()) {
                                                        TSelectSqlStatement subquery = table.getSubquery();
                                                        List<ResultSet> resultSets = new ArrayList<ResultSet>();
                                                        if (!subquery.getLeftStmt().isCombinedQuery()) {
                                                                ResultSet sourceResultSet = (ResultSet) modelManager
                                                                                .getModel(subquery.getLeftStmt().getResultColumnList());
                                                                resultSets.add(sourceResultSet);
                                                        } else {
                                                                ResultSet sourceResultSet = (ResultSet) modelManager.getModel(subquery.getLeftStmt());
                                                                resultSets.add(sourceResultSet);
                                                        }

                                                        if (!subquery.getRightStmt().isCombinedQuery()) {
                                                                ResultSet sourceResultSet = (ResultSet) modelManager
                                                                                .getModel(subquery.getRightStmt().getResultColumnList());
                                                                resultSets.add(sourceResultSet);
                                                        } else {
                                                                ResultSet sourceResultSet = (ResultSet) modelManager.getModel(subquery.getRightStmt());
                                                                resultSets.add(sourceResultSet);
                                                        }

                                                        int sourcesBefore = relation.getSources().size();
                                                        for (ResultSet sourceResultSet : resultSets) {
                                                                if (sourceResultSet != null && columnName.getSourceColumn() != null) {
                                                                        for (int k = 0; k < sourceResultSet.getColumns().size(); k++) {
                                                                                if (DlineageUtil.sameColumnName(sourceResultSet.getColumns().get(k).getName(), columnName.getSourceColumn().getColumnNameOnly())) {
                                                                                        ResultColumn linkedColumn = sourceResultSet.getColumns().get(k);
                                                                                        int link = linkedColumn.starLinkIndexOf(columnName);
                                                                                        if (link >= 0) {
                                                                                                ResultColumn column = modelFactory.createResultColumn(sourceResultSet,
                                                                                                                linkedColumn.getStarLinkColumnName(link), true);
                                                                                                ResultColumnRelationshipElement setopElement = new ResultColumnRelationshipElement(column);
                                                                                                setopElement.setReferencePosition(columnName);
                                                                                                relation.addSource(setopElement);
                                                                                        } else {
                                                                                                ResultColumnRelationshipElement setopElement = new ResultColumnRelationshipElement(
                                                                                                                sourceResultSet.getColumns().get(k));
                                                                                                setopElement.setReferencePosition(columnName);
                                                                                                relation.addSource(setopElement);
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                        // The resolver bound the column to the set-operation derived table without a parse-time source
                                                        // column (UNION ALL ... AS r ON r.type = c.cos_type): the derived table's own column is the
                                                        // row influence (Mantis 4819), as a VALUES derived table's is.
                                                        if (relation.getSources().size() == sourcesBefore && tableModel.getColumns() != null) {
                                                                for (ResultColumn ownColumn : tableModel.getColumns()) {
                                                                        if (DlineageUtil.columnMatches(ownColumn, columnName)) {
                                                                                relation.addSource(new ResultColumnRelationshipElement(ownColumn,
                                                                                                columnName.getLocation(), columnName));
                                                                                break;
                                                                        }
                                                                }
                                                        }
                                                } else {
                                                        Object model = modelManager.getModel(columnName.getSourceColumn());
                                                        if (model instanceof ResultColumn) {
                                                                ResultColumn resultColumn = (ResultColumn) model;
                                                                if (resultColumn != null) {
                                                                        if (resultColumn.hasStarLinkColumn()) {
                                                                                int link = resultColumn.starLinkIndexOf(columnName);
                                                                                if (link >= 0) {
                                                                                        ResultColumn column = modelFactory.createResultColumn(
                                                                                                        resultColumn.getResultSet(), resultColumn.getStarLinkColumnName(link), true);
                                                                                        ResultColumnRelationshipElement starElement = new ResultColumnRelationshipElement(column);
                                                                                        starElement.setReferencePosition(columnName);
                                                                                        relation.addSource(starElement);
                                                                                } else {
                                                                                        resultColumn.bindStarLinkColumn(columnName);
                                                                                        ResultColumn column = modelFactory
                                                                                                        .createResultColumn(resultColumn.getResultSet(), columnName, true);
                                                                                        ResultColumnRelationshipElement starElement = new ResultColumnRelationshipElement(column);
                                                                                        starElement.setReferencePosition(columnName);
                                                                                        relation.addSource(starElement);
                                                                                }
                                                                        } else {
                                                                                // Carry the operand's own reference site: the
                                                                                // derived table's / CTE's result column model
                                                                                // carries its select-list definition span, not
                                                                                // where this ON/WHERE operand sits.
                                                                                ResultColumnRelationshipElement element = new ResultColumnRelationshipElement(
                                                                                                resultColumn, columnName.getLocation(), columnName);
                                                                                relation.addSource(element);
                                                                        }
                                                                }
                                                        }
                                                        else{
                                                                boolean find = false;
                                                                // STRUCT tree: customer.address.city reads the column customer of the CTE or subquery;
                                                                // matched by its last segment it found none and invented a column
                                                                ResultColumn fieldReadBase = structFieldReadSource(
                                                                                structFieldReadBaseColumn(columnName, tableModel.getColumns()), columnName);
                                                                if (fieldReadBase != null) {
                                                                        relation.addSource(new ResultColumnRelationshipElement(fieldReadBase,
                                                                                        columnName.getLocation(), columnName));
                                                                        find = true;
                                                                }
                                                                for (int i = 0; !find && i < tableModel.getColumns().size(); i++) {
                                                                        ResultColumn resultColumn = tableModel.getColumns().get(i);
                                                                        if (DlineageUtil.columnMatches(resultColumn, columnName)) {
                                                                                // An explicit CTE column list resolves here;
                                                                                // the model span is the column-list entry, not
                                                                                // the operand.
                                                                                ResultColumnRelationshipElement element = new ResultColumnRelationshipElement(
                                                                                                resultColumn, columnName.getLocation(), columnName);
                                                                                relation.addSource(element);
                                                                                find = true;
                                                                                break;
                                                                        }
                                                                        else if (resultColumn.isStarColumn()) {
                                                                                resultColumn.bindStarLinkColumn(columnName);
                                                                        }
                                                                }
                                                                if(!find){
                                                                        ResultColumn resultColumn = new ResultColumn(tableModel, columnName);
                                                                        ResultColumnRelationshipElement element = new ResultColumnRelationshipElement(
                                                                                                resultColumn, columnName.getLocation(), columnName);
                                                                                relation.addSource(element);
                                                                }
                                                        }
                                                }
                                        } else if (functionOutputColumn(modelManager.getModel(table)) != null) {
                                                // A table function's column is read through its output column, as the select list reads it
                                                // (Mantis 4797).
                                                relation.addSource(new ResultColumnRelationshipElement(
                                                                functionOutputColumn(modelManager.getModel(table)), columnName.getLocation(), columnName));
                                        }
                                }
                        }
                        } finally {
                                if (sqllrRefs != null) {
                                        sqllrRefs.closeFrame(sqllrFrame);
                                }
                        }

                        ESqlClause operandClause = filterOperandClause(joinClauseType);
                        for (int j = 0; j < functions.size(); j++) {
                                TParseTreeNode functionObj = functions.get(j);
                                Object functionModel = modelManager.getModel(functionObj);
                                if (functionModel == null) {
                                        functionModel = createFunction(functionObj);
                                }
                                if (functionModel instanceof Function) {
                                        if (functionObj instanceof TFunctionCall) {
                                                ResultColumn resultColumn = (ResultColumn) modelManager
                                                                .getModel(((TFunctionCall) functionObj).getFunctionName());
                                                if (resultColumn != null) {
                                                        ResultColumnRelationshipElement element = new ResultColumnRelationshipElement(resultColumn,
                                                                        operandClause != null ? operandClause
                                                                                        : ((TFunctionCall) functionObj).getFunctionName().getLocation());
                                                        relation.addSource(element);
                                                }
                                        }
                                        if (functionObj instanceof TCaseExpression) {
                                                ResultColumn resultColumn = (ResultColumn) modelManager
                                                                .getModel(((TCaseExpression) functionObj).getWhenClauseItemList());
                                                if (resultColumn != null) {
                                                        ResultColumnRelationshipElement element = new ResultColumnRelationshipElement(resultColumn,
                                                                        operandClause);
                                                        relation.addSource(element);
                                                }
                                        }
                                } else if (functionModel instanceof Table && ((TFunctionCall) functionObj).getFunctionName()!=null) {
                                        TableColumn tableColumn = modelFactory.createTableColumn((Table) functionModel,
                                                        ((TFunctionCall) functionObj).getFunctionName(), false);
                                        if (tableColumn != null) {
                                                TableColumnRelationshipElement element = new TableColumnRelationshipElement(tableColumn,
                                                                operandClause);
                                                relation.addSource(element);
                                        }
                                }
                        }

                        for (int j = 0; j < resultColumns.size(); j++) {
                                TResultColumn resultColumn = resultColumns.get(j);
                                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
                                        ResultColumn resultColumnModel = (ResultColumn) modelManager.getModel(resultColumn);
                                        relation.addSource(new ResultColumnRelationshipElement(resultColumnModel, ESqlClause.selectList));
                                }
                        }
                }

                // a HAVING predicate filters groups: two columns compared there are not a join
                if (isShowJoin() && joinClauseType != null && joinClauseType != JoinClauseType.having) {
                        joinInExpr joinVisitor = new joinInExpr(joinType, joinClauseType, effectType);
                        expr.inOrderTraverse(joinVisitor);
                }
                // an aggregate in HAVING reads its group as one in the select list does: the GROUP BY keys and the rows
                if (joinClauseType == JoinClauseType.having) {
                        analyzeRecordSetRelation(functions, effectType, true);
                }
                return relation;
        }

        public void dispose() {
        if (commentBindingCollector != null) { commentBindingCollector.clear(); commentBindingCollector = null; }
                usingColumnsByStatement.clear();
                scopeBuildResult = null;
                authoritativeEvidenceCollector.reset();
                cteSelectRelationKeys.clear();
                accessedSubqueries.clear();
                accessedStatements.clear();
                stmtStack.clear();
                viewDDLMap.clear();
                procedureDDLAliases.clear();
                deferredExecuteBindings.clear();
                structObjectMap.clear();
                appendResultSets.clear();
                appendStarColumns.clear();
                appendTableStarColumns.clear();
                columnNameIndexCache.clear();
                resultSetColumnLookupCache.clear();
                tableColumnLookupCache.clear();
                modelManager.DISPLAY_ID.clear();
                modelManager.DISPLAY_NAME.clear();
                tableIds.clear();
                ModelBindingManager.remove();
        }

        class joinTreatColumnsInExpr implements IExpressionVisitor {

                private List<TObjectName> objectNames = new ArrayList<TObjectName>();
                
                private TTable table;

                public joinTreatColumnsInExpr(TTable table) {
                        this.table = table;
                }

                public List<TObjectName> getObjectNames() {
                        return objectNames;
                }

                boolean is_compare_condition(EExpressionType t) {
                        return t == EExpressionType.simple_comparison_t;
                }

                @Override
                public boolean exprVisit(TParseTreeNode pNode, boolean isLeafNode) {
                        TExpression expr = (TExpression) pNode;
                        if (is_compare_condition(expr.getExpressionType())) {
                                TExpression leftExpr = expr.getLeftOperand();
                                columnsInExpr leftVisitor = new columnsInExpr();
                                leftExpr.inOrderTraverse(leftVisitor);
                                List<TObjectName> leftObjectNames = leftVisitor.getObjectNames();

                                TExpression rightExpr = expr.getRightOperand();
                                columnsInExpr rightVisitor = new columnsInExpr();
                                rightExpr.inOrderTraverse(rightVisitor);
                                List<TObjectName> rightObjectNames = rightVisitor.getObjectNames();

                                if (!leftObjectNames.isEmpty() && !rightObjectNames.isEmpty()) {
                                        for (TObjectName column : leftObjectNames) {
                                                if (column.getSourceTable() != null && column.getSourceTable().equals(table)) {
                                                        objectNames.add(column);
                                                        return false;
                                                }
                                        }
                                        for (TObjectName column : rightObjectNames) {
                                                if (column.getSourceTable() != null && column.getSourceTable().equals(table)) {
                                                        objectNames.add(column);
                                                        return false;
                                                }
                                        }
                                }
                                return false;
                        }
                        return true;
                }
        }
        
        class columnsInExpr implements IExpressionVisitor {

                private List<TParseTreeNode> constants = new ArrayList<TParseTreeNode>();
                private List<TObjectName> objectNames = new ArrayList<TObjectName>();
                private List<TParseTreeNode> functions = new ArrayList<TParseTreeNode>();
                private List<TResultColumn> resultColumns = new ArrayList<TResultColumn>();
                private List<TSelectSqlStatement> subquerys = new ArrayList<TSelectSqlStatement>();
                private boolean skipFunction = false;
                // ClickHouse expression-CTE aliases already substituted during this
                // traversal — guards against cyclic alias definitions.
                private Set<TCTE> expandedExpressionCtes = new HashSet<TCTE>();
                // Alias-chain expansion is depth-bounded hybrid: direct recursion
                // preserves depth-first substitution order (source order of the
                // collected columns) up to CTE_EXPANSION_MAX_DEPTH; deeper chains
                // queue their definitions on an explicit deque drained by the
                // outermost frame — a 2000-alias chain must not overflow the -Xss2m
                // stack (same class as the repo's UNION/expression traversal rule).
                private static final int CTE_EXPANSION_MAX_DEPTH = 64;
                private Deque<TExpression> pendingCteExpressions = new ArrayDeque<TExpression>();
                private int cteExpansionDepth = 0;
                // subscript expressions traversed, by identity: a name, its call and its expression can share them (Mantis 4817)
                private Set<TExpression> subscriptsTraversed = Collections.newSetFromMap(new IdentityHashMap<TExpression, Boolean>());

                private void traverseSubscripts(List<TExpression> subscripts) {
                        for (TExpression subscript : subscripts) {
                                if (subscript != null && subscriptsTraversed.add(subscript)) {
                                        subscript.inOrderTraverse(this);
                                }
                        }
                }

                /**
                 * Collects an expression operand as a column reference — unless it is a
                 * ClickHouse expression-CTE alias (WITH <expr> AS ident), in which case
                 * the CTE's definition is traversed instead so its real column
                 * dependencies flow to the consumer. Every branch of exprVisit that
                 * adds an operand's TObjectName directly must go through this method,
                 * or alias references in that expression shape leak out as columns.
                 */
                private void addColumnOrExpandCteAlias(TObjectName object) {
                        if (object.getExpressionCteRef() == null
                                        || object.getSourceTable() != null
                                        || object.getExpressionCteRef().getExpression() == null) {
                                objectNames.add(object);
                                return;
                        }
                        if (!expandedExpressionCtes.add(object.getExpressionCteRef())) {
                                return; // cyclic or already substituted
                        }
                        TExpression definition = object.getExpressionCteRef().getExpression();
                        if (cteExpansionDepth >= CTE_EXPANSION_MAX_DEPTH) {
                                pendingCteExpressions.add(definition);
                                return; // drained below when the outermost frame unwinds
                        }
                        cteExpansionDepth++;
                        try {
                                definition.inOrderTraverse(this);
                        } finally {
                                cteExpansionDepth--;
                        }
                        if (cteExpansionDepth == 0) {
                                while (!pendingCteExpressions.isEmpty()) {
                                        TExpression pending = pendingCteExpressions.poll();
                                        cteExpansionDepth++;
                                        try {
                                                pending.inOrderTraverse(this);
                                        } finally {
                                                cteExpansionDepth--;
                                        }
                                }
                        }
                }

                public void setSkipFunction(boolean skipFunction) {
                        this.skipFunction = skipFunction;
                }

                public List<TParseTreeNode> getFunctions() {
                        return functions;
                }

                public List<TSelectSqlStatement> getSubquerys() {
                        return subquerys;
                }

                public List<TParseTreeNode> getConstants() {
                        return constants;
                }

                public List<TObjectName> getObjectNames() {
                        return objectNames;
                }

                public List<TResultColumn> getResultColumns() {
                        return resultColumns;
                }

                @Override
                public boolean exprVisit(TParseTreeNode pNode, boolean isLeafNode) {
                        TExpression lcexpr = (TExpression) pNode;
                        // Handle named argument expressions (e.g., "INPUT => value" in Snowflake FLATTEN)
                        // The left operand is the parameter name, NOT a column reference.
                        // Only traverse the right operand (the value).
                        if (lcexpr.getExpressionType() == EExpressionType.assignment_t) {
                                // Skip left operand (parameter name) - only traverse right operand (value)
                                if (lcexpr.getRightOperand() != null) {
                                        lcexpr.getRightOperand().inOrderTraverse(this);
                                }
                                return false; // Don't continue default traversal
                        }
                        if (lcexpr.getExpressionType() == EExpressionType.simple_constant_t) {
                                if (lcexpr.getConstantOperand() != null) {
                                        TExpression intervalValue = lcexpr.getConstantOperand().getInt64_expression();
                                        if(intervalValue!=null
                                                        && intervalValue.getExpressionType() == EExpressionType.function_t) {
                                                intervalValue.inOrderTraverse(this);
                                        }
                                        else {
                                                constants.add(lcexpr.getConstantOperand());
                                                if (intervalValue != null && intervalValue.getExpressionType() != EExpressionType.simple_constant_t) {
                                                        // INTERVAL t.n DAY (BigQuery, MySQL): the value of the interval reads columns (Mantis 4918);
                                                        // its literals stay the one interval constant added above
                                                        int constantCount = constants.size();
                                                        intervalValue.inOrderTraverse(this);
                                                        constants.subList(constantCount, constants.size()).clear();
                                                }
                                        }
                                }
                        } else if (lcexpr.getExpressionType() == EExpressionType.interval_t) {
                                // (a - b) SECOND(4) (Teradata): the qualified value is a leaf of the traversal, so the columns it reads
                                // are visited here (Mantis 4918); its literals are dropped, so INTERVAL 1 DAY or INTERVAL (-1) DAY
                                // still collects nothing, as before
                                TExpression intervalValue = lcexpr.getIntervalExpr() == null ? null : lcexpr.getIntervalExpr().getExpr();
                                if (intervalValue != null && intervalValue.getExpressionType() != EExpressionType.simple_constant_t) {
                                        int constantCount = constants.size();
                                        intervalValue.inOrderTraverse(this);
                                        constants.subList(constantCount, constants.size()).clear();
                                }
                        } else if (lcexpr.getExpressionType() == EExpressionType.row_constructor_t
                                        || (lcexpr.getExpressionType() == EExpressionType.array_constructor_t
                                                        && lcexpr.getExprList() != null)) {
                                // ROW(a, b): every value of the row is a source (Mantis 4834); ARRAY[a, b] (PostgreSQL, the Trino
                                // family, Redshift, Snowflake): every element is a source, as BigQuery's [a, b] (plan section 4.5,
                                // Mantis 4878). The expression is a leaf of the traversal, so its values are visited here;
                                // ARRAY(SELECT ...) has no list and keeps its subquery path
                                if (lcexpr.getExprList() != null) {
                                        for (int j = 0; j < lcexpr.getExprList().size(); j++) {
                                                TExpression expr = lcexpr.getExprList().getExpression(j);
                                                if (expr != null)
                                                        expr.inOrderTraverse(this);
                                        }
                                }
                        } else if (lcexpr.getExpressionType() == EExpressionType.array_t) {
                                if(lcexpr.getObjectOperand()!=null) {
                                        TObjectName object = lcexpr.getObjectOperand();
                                        addColumnOrExpandCteAlias(object);
                                } else if (lcexpr.getExprList() != null) {
                                        for (int j = 0; j < lcexpr.getExprList().size(); j++) {
                                                TExpression expr = lcexpr.getExprList().getExpression(j);
                                                if (expr != null)
                                                        expr.inOrderTraverse(this);
                                        }
                                }
                        } else if (lcexpr.getExpressionType() == EExpressionType.simple_object_name_t) {
                                if (lcexpr.getObjectOperand() != null && !(isBuiltInFunctionName(lcexpr.getObjectOperand())
                                                && isFromFunction(lcexpr.getObjectOperand()))) {
                                        TObjectName object = lcexpr.getObjectOperand();
                                        // Skip named argument parameter names (e.g., INPUT in "INPUT => value")
                                        // and lambda parameters (x in "x -> x + 1", marked by TSQLResolver2).
                                        // These are function parameter names, NOT column references
                                        if (object.getObjectType() == TObjectName.ttobjNamedArgParameter
                                                        || object.getObjectType() == TObjectName.ttobjLambdaParameter) {
                                                // Skip - this is a named argument or lambda parameter name
                                        } else if (object.getDbObjectType() == EDbObjectType.column
                                                        || object.getDbObjectType() == EDbObjectType.column_alias
                                                        || object.getDbObjectType() == EDbObjectType.alias
                                                        || object.getDbObjectType() == EDbObjectType.unknown
                                                        || object.getDbObjectType() == EDbObjectType.variable
                                                        || isTableScopedPseudoColumn(object)) {
                                                addColumnOrExpandCteAlias(object);
                                        } else if (object.getDbObjectType() == EDbObjectType.notAColumn
                                                        || object.getDbObjectType() == EDbObjectType.date_time_part ) {
                                                constants.add(object);
                                        }
                                        // arr[n]: the subscript selects the element, so n is a source too (Mantis 4817)
                                        traverseSubscripts(object.getSubscriptExpressions());
                                        traverseSubscripts(lcexpr.getSubscriptExpressions());
                                }
                        } else if (lcexpr.getExpressionType() == EExpressionType.between_t) {
                                if (lcexpr.getBetweenOperand() != null && lcexpr.getBetweenOperand().getObjectOperand() != null) {
                                        TObjectName object = lcexpr.getBetweenOperand().getObjectOperand();
                                        if (object.getDbObjectType() == EDbObjectType.column
                                                        || object.getDbObjectType() == EDbObjectType.column_alias
                                                        || object.getDbObjectType() == EDbObjectType.alias
                                                        || object.getDbObjectType() == EDbObjectType.unknown
                                                        || object.getDbObjectType() == EDbObjectType.variable) {
                                                addColumnOrExpandCteAlias(object);
                                        }
                                }
                        } else if (lcexpr.getExpressionType() == EExpressionType.new_structured_type_t) {
                                // NEW JSON(t.e, LATIN) and NEW JSON(...).JSONEXTRACTVALUE('$.a') (Teradata): the constructor and its
                                // methods are a list the traversal does not enter, so they are visited here (Mantis 4919)
                                if (lcexpr.getExprList() != null) {
                                        for (int j = 0; j < lcexpr.getExprList().size(); j++) {
                                                TExpression expr = lcexpr.getExprList().getExpression(j);
                                                if (expr != null)
                                                        expr.inOrderTraverse(this);
                                        }
                                }
                        } else if (lcexpr.getExpressionType() == EExpressionType.object_access_t) {
                                if (lcexpr.getObjectAccess() != null) {
                                        TObjectNameList objects = lcexpr.getObjectAccess().getAttributes();
                                        TFunctionCall function = lcexpr.getObjectAccess().getObjectExpr().getFunctionCall();
                                        if (objects != null && function != null) {
                                                for (TObjectName object : objects) {
                                                        TGSqlParser sqlparser = createSqlParser(option.getVendor());
                                                        sqlparser.sqltext = "select " + function.getFunctionName().toString() + "."
                                                                        + object.getColumnNameOnly() + " from " + function.getFunctionName().toString();
                                                        if (parseWithCommentBindings(sqlparser) == 0) {
                                                                TObjectName objectName = sqlparser.sqlstatements.get(0).getResultColumnList()
                                                                                .getResultColumn(0).getFieldAttr();
                                                                objectNames.add(objectName);
                                                        }
                                                }
                                        } else {
                                                // (NEW JSON(t.e)).JSONEXTRACTVALUE('$.a'), XMLTYPE(t.c).getStringVal(): a method reads the value
                                                // of the object it is called on (Mantis 4919)
                                                lcexpr.getObjectAccess().getObjectExpr().inOrderTraverse(this);
                                        }
                                }
                        } else if (lcexpr.getExpressionType() == EExpressionType.function_t || lcexpr.getExpressionType() == EExpressionType.fieldselection_t) {
                                TFunctionCall func = lcexpr.getFunctionCall();
                                if (func == null) {
                                        return true;
                                }
                                if (skipFunction) {
                                        if (func.getArgs() != null) {
                                                for (int k = 0; k < func.getArgs().size(); k++) {
                                                        TExpression expr = func.getArgs().getExpression(k);
                                                        if (expr != null)
                                                                expr.inOrderTraverse(this);
                                                }
                                        }

                                        if (func.getTrimArgument() != null) {
                                                TTrimArgument args = func.getTrimArgument();
                                                TExpression expr = args.getStringExpression();
                                                if (expr != null) {
                                                        expr.inOrderTraverse(this);
                                                }
                                                expr = args.getTrimCharacter();
                                                if (expr != null) {
                                                        expr.inOrderTraverse(this);
                                                }
                                        }

                                        if (func.getAgainstExpr() != null) {
                                                func.getAgainstExpr().inOrderTraverse(this);
                                        }
//                                      if (func.getBetweenExpr() != null) {
//                                              func.getBetweenExpr().inOrderTraverse(this);
//                                      }
                                        if (func.getExpr1() != null) {
                                                func.getExpr1().inOrderTraverse(this);
                                        }
                                        if (func.getExpr2() != null) {
                                                func.getExpr2().inOrderTraverse(this);
                                        }
                                        if (func.getExpr3() != null) {
                                                func.getExpr3().inOrderTraverse(this);
                                        }
                                        if (func.getParameter() != null) {
                                                func.getParameter().inOrderTraverse(this);
                                        }
                                        // split(s, ':')[n]: the subscript after the call reads n (Mantis 4817)
                                        traverseSubscripts(func.getSubscriptExpressions());
                                        traverseSubscripts(lcexpr.getSubscriptExpressions());
                                } else {
                                        functions.add(func);
                                        // the subscript after the call: the selected element depends on it (Mantis 4817); the call's own
                                        // subscripts become the function's sources through getFunctionExpressions
                                        traverseSubscripts(lcexpr.getSubscriptExpressions());
                                }

                        } else if (lcexpr.getExpressionType() == EExpressionType.case_t) {
                                TCaseExpression expr = lcexpr.getCaseExpression();
                                if (skipFunction) {
                                        TExpression defaultExpr = expr.getElse_expr();
                                        if (defaultExpr != null) {
                                                defaultExpr.inOrderTraverse(this);
                                        }
                                        TWhenClauseItemList list = expr.getWhenClauseItemList();
                                        for (int i = 0; i < list.size(); i++) {
                                                TWhenClauseItem element = (TWhenClauseItem) list.getElement(i);
                                                (((TWhenClauseItem) element).getReturn_expr()).inOrderTraverse(this);

                                        }
                                } else {
                                        functions.add(expr);
                                }
                        } else if (lcexpr.getSubQuery() != null) {
                                TSelectSqlStatement select = lcexpr.getSubQuery();
                                analyzeSelectStmt(select);
                                subquerys.add(select);
                                if (select.getResultColumnList() != null && select.getResultColumnList().size() > 0) {
                                        for (TResultColumn column : select.getResultColumnList()) {
                                                resultColumns.add(column);
                                        }
                                }
                        }
                        return true;
                }
        }

        class joinInExpr implements IExpressionVisitor {

                private EJoinType joinType;
                private JoinClauseType joinClauseType;
                private EffectType effectType;

                public joinInExpr(EJoinType joinType, JoinClauseType joinClauseType, EffectType effectType) {
                        this.joinType = joinType;
                        this.joinClauseType = joinClauseType;
                        this.effectType = effectType;
                }

                boolean is_compare_condition(EExpressionType t) {
                        return ((t == EExpressionType.simple_comparison_t) || (t == EExpressionType.group_comparison_t)
                                        || (t == EExpressionType.in_t) || (t == EExpressionType.pattern_matching_t)
                                        || (t == EExpressionType.left_join_t) || (t == EExpressionType.right_join_t));
                }

                @Override
                public boolean exprVisit(TParseTreeNode pNode, boolean isLeafNode) {
                        TExpression expr = (TExpression) pNode;
                        if (is_compare_condition(expr.getExpressionType())) {
                                TExpression leftExpr = expr.getLeftOperand();
                                columnsInExpr leftVisitor = new columnsInExpr();
                                leftExpr.inOrderTraverse(leftVisitor);
                                List<TObjectName> leftObjectNames = leftVisitor.getObjectNames();
                                List<TParseTreeNode> leftObjects = leftVisitor.getFunctions();
                                leftObjects.addAll(leftObjectNames);
                                
                                TExpression rightExpr = expr.getRightOperand();
                                columnsInExpr rightVisitor = new columnsInExpr();
                                rightExpr.inOrderTraverse(rightVisitor);
                                List<TObjectName> rightObjectNames = rightVisitor.getObjectNames();
                                List<TParseTreeNode> rightObjects = rightVisitor.getFunctions();
                                rightObjects.addAll(rightObjectNames);

                                if (!leftObjects.isEmpty() && !rightObjects.isEmpty()) {
                                        TCustomSqlStatement stmt = stmtStack.peek();

                                        for (int i = 0; i < leftObjects.size(); i++) {
                                                TParseTreeNode leftObject = leftObjects.get(i);
                                                TTable leftTable = null;
                                                TFunctionCall leftFunction = null;
                                                TObjectName leftObjectName = null;
                                                if (leftObject instanceof TObjectName) {
                                                        leftObjectName = (TObjectName)leftObject;

                                                        if (leftObjectName.getDbObjectType() == EDbObjectType.variable) {
                                                                continue;
                                                        }

                                                        if (leftObjectName.getColumnNameOnly().startsWith("@")
                                                                        && (option.getVendor() == EDbVendor.dbvmssql
                                                                                        || option.getVendor() == EDbVendor.dbvazuresql)) {
                                                                continue;
                                                        }

                                                        if (leftObjectName.getColumnNameOnly().startsWith(":")
                                                                        && (option.getVendor() == EDbVendor.dbvhana
                                                                                        || option.getVendor() == EDbVendor.dbvteradata)) {
                                                                continue;
                                                        }

                                                        leftTable = modelManager.getTable(stmt, leftObjectName);

                                                        if (leftTable == null) {
                                                                leftTable = leftObjectName.getSourceTable();
                                                        }

                                                        if (leftTable == null) {
                                                                leftTable = modelManager.guessTable(stmt, leftObjectName);
                                                        }
                                                }
                                                else if(leftObject instanceof TFunctionCall){
                                                        leftFunction = (TFunctionCall)leftObject;
                                                }

                                                if (leftTable != null || leftFunction != null) {
                                                        for (int j = 0; j < rightObjects.size(); j++) {
                                                                JoinRelationship joinRelation = modelFactory.createJoinRelation();
                                                                joinRelation.setEffectType(effectType);
                                                                if (joinType != null) {
                                                                        joinRelation.setJoinType(joinType);
                                                                } else {
                                                                        if (expr.getLeftOperand().isOracleOuterJoin()) {
                                                                                joinRelation.setJoinType(right);
                                                                        } else if (expr.getRightOperand().isOracleOuterJoin()) {
                                                                                joinRelation.setJoinType(EJoinType.left);
                                                                        } else if (expr.getExpressionType() == EExpressionType.left_join_t) {
                                                                                joinRelation.setJoinType(EJoinType.left);
                                                                        } else if (expr.getExpressionType() == EExpressionType.right_join_t) {
                                                                                joinRelation.setJoinType(right);
                                                                        } else {
                                                                                joinRelation.setJoinType(EJoinType.inner);
                                                                        }
                                                                }

                                                                joinRelation.setJoinClauseType(joinClauseType);
                                                                joinRelation.setJoinCondition(expr.toString());


                                                                if (leftTable != null) {
                                                                        if (functionOutputColumn(modelManager.getModel(leftTable)) != null) {
                                                                                // a table function's column is its output column (Mantis 4815)
                                                                                joinRelation.addSource(new ResultColumnRelationshipElement(
                                                                                                functionOutputColumn(modelManager.getModel(leftTable))));
                                                                        } else if (modelManager.getModel(leftTable) instanceof Table) {
                                                                                Table tableModel = (Table) modelManager.getModel(leftTable);
                                                                                if (tableModel != null) {
                                                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel,
                                                                                                        leftObjectName, false);
                                                                                        if (columnModel != null) {
                                                                                                joinRelation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                                        }
                                                                                }
                                                                        } else if (modelManager.getModel(leftTable) instanceof QueryTable) {
                                                                                QueryTable table = (QueryTable) modelManager.getModel(leftTable);
                                                                                TSelectSqlStatement subquery = table.getTableObject().getSubquery();
                                                                                if (subquery != null && subquery.isCombinedQuery()) {
                                                                                        ResultColumn resultColumn = matchResultColumn(table.getColumns(),
                                                                                                        leftObjectName);
                                                                                        if (resultColumn != null) {
                                                                                                joinRelation
                                                                                                                .addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                        }
                                                                                } else if (leftObjectName.getSourceColumn() != null) {
                                                                                        Object model = modelManager.getModel(leftObjectName);
                                                                                        if (model == null) {
                                                                                                model = modelFactory.createResultColumn(table, leftObjectName);
                                                                                        }
                                                                                        if (model instanceof ResultColumn) {
                                                                                                ResultColumn resultColumn = (ResultColumn) model;
                                                                                                if (resultColumn != null) {
                                                                                                        joinRelation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(resultColumn));
                                                                                                }
                                                                                        } else if (model instanceof LinkedHashMap) {
                                                                                                String columnName = getColumnNameOnly(leftObjectName.toString());
                                                                                                LinkedHashMap<String, ResultColumn> resultColumns = (LinkedHashMap<String, ResultColumn>) model;
                                                                                                if (resultColumns.containsKey(columnName)) {
                                                                                                        ResultColumn resultColumn = resultColumns.get(columnName);
                                                                                                        joinRelation.addSource(
                                                                                                                        new ResultColumnRelationshipElement(resultColumn));
                                                                                                }
                                                                                        }
                                                                                } else {
                                                                                        ResultColumn resultColumn = matchResultColumn(table.getColumns(),
                                                                                                        leftObjectName);
                                                                                        if (resultColumn != null) {
                                                                                                joinRelation
                                                                                                                .addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                                else if(leftFunction!=null) {
                                                                        Object functionObj = createFunction(leftFunction);
                                                                        if(functionObj instanceof Function) {
                                                                                Function function = (Function)functionObj;
                                                                                joinRelation.addSource(new ResultColumnRelationshipElement(function.getColumns().get(0)));
                                                                        }
                                                                }

                                                                TParseTreeNode rightObject = rightObjects.get(j);
                                                                if(rightObject instanceof TObjectName) {
                                                                        TObjectName rightObjectName = (TObjectName)rightObject;

                                                                        if (rightObjectName.getDbObjectType() == EDbObjectType.variable) {
                                                                                continue;
                                                                        }

                                                                        if (rightObjectName.getColumnNameOnly().startsWith("@")
                                                                                        && (option.getVendor() == EDbVendor.dbvmssql
                                                                                                        || option.getVendor() == EDbVendor.dbvazuresql)) {
                                                                                continue;
                                                                        }

                                                                        if (rightObjectName.getColumnNameOnly().startsWith(":")
                                                                                        && (option.getVendor() == EDbVendor.dbvhana
                                                                                                        || option.getVendor() == EDbVendor.dbvteradata)) {
                                                                                continue;
                                                                        }

                                                                        TTable rightTable = modelManager.getTable(stmt, rightObjectName);
                                                                        if (rightTable == null) {
                                                                                rightTable = rightObjectName.getSourceTable();
                                                                        }

                                                                        if (rightTable == null) {
                                                                                rightTable = modelManager.guessTable(stmt, rightObjectName);
                                                                        }

                                                                        if (functionOutputColumn(modelManager.getModel(rightTable)) != null) {
                                                                                // a table function's column is its output column (Mantis 4815)
                                                                                joinRelation.setTarget(new ResultColumnRelationshipElement(
                                                                                                functionOutputColumn(modelManager.getModel(rightTable))));
                                                                        } else if (modelManager.getModel(rightTable) instanceof Table) {
                                                                                Table tableModel = (Table) modelManager.getModel(rightTable);
                                                                                if (tableModel != null) {
                                                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel,
                                                                                                        rightObjectName, false);
                                                                                        if(columnModel != null) {
                                                                                                joinRelation.setTarget(new TableColumnRelationshipElement(columnModel));
                                                                                        }
                                                                                }
                                                                        } else if (modelManager.getModel(rightTable) instanceof QueryTable) {
                                                                                QueryTable table = (QueryTable) modelManager.getModel(rightTable);
                                                                                TSelectSqlStatement subquery = table.getTableObject().getSubquery();
                                                                                if (subquery != null && subquery.isCombinedQuery()) {
                                                                                        ResultColumn resultColumn = matchResultColumn(table.getColumns(),
                                                                                                        rightObjectName);
                                                                                        if (resultColumn != null) {
                                                                                                joinRelation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                        }
                                                                                } else if (rightObjectName.getSourceColumn() != null) {
                                                                                        Object model = modelManager.getModel(rightObjectName);
                                                                                        if (model == null) {
                                                                                                model = modelManager
                                                                                                                .getModel(rightObjectName.getSourceColumn());
                                                                                        }
                                                                                        if (model instanceof ResultColumn) {
                                                                                                joinRelation.setTarget(new ResultColumnRelationshipElement((ResultColumn)model));
                                                                                        }
                                                                                        else if (model instanceof LinkedHashMap) {
                                                                                                String columnName = getColumnNameOnly(rightObjectName.toString());
                                                                                                LinkedHashMap<String, ResultColumn> resultColumns = (LinkedHashMap<String, ResultColumn>)model;
                                                                                                if (resultColumns.containsKey(columnName)) {
                                                                                                        ResultColumn resultColumn = resultColumns.get(columnName);
                                                                                                        joinRelation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                }
                                                                                        }
                                                                                } else {
                                                                                        ResultColumn resultColumn = matchResultColumn(table.getColumns(),
                                                                                                        rightObjectName);
                                                                                        if (resultColumn != null) {
                                                                                                joinRelation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                                else if(rightObject instanceof TFunctionCall) {
                                                                        Object functionObj = createFunction(rightObject);
                                                                        if(functionObj instanceof Function) {
                                                                                Function function = (Function)functionObj;
                                                                                joinRelation.setTarget(new ResultColumnRelationshipElement(function.getColumns().get(0)));
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                        return true;
                }
        }

        @Deprecated
        public static Dataflow getSqlflowJSONModel(dataflow dataflow) {
                EDbVendor vendor = ModelBindingManager.getGlobalVendor();
                if(vendor == null) {
                        throw new IllegalArgumentException("getSqlflowJSONModel(dataflow dataflow) is deprecated, please call method getSqlflowJSONModel(dataflow dataflow, EDbVendor vendor).");
                }
                return getSqlflowJSONModel(vendor, dataflow, false);
        }

        public static Dataflow getSqlflowJSONModel(dataflow dataflow, EDbVendor vendor) {
                return getSqlflowJSONModel(vendor, dataflow, false);
        }

        public static Dataflow getSqlflowJSONModel(EDbVendor vendor, dataflow dataflow, boolean normalizeIdentifier) {
                Dataflow model = new Dataflow();
        if (dataflow != null) model.setCommentBindings(dataflow.getCommentBindings());
                
                if (dataflow.getErrors() != null && !dataflow.getErrors().isEmpty()) {
                        List<Error> errorList = new ArrayList<Error>();
                        for (error error : dataflow.getErrors()) {
                                Error err = new Error();
                                err.setErrorMessage(error.getErrorMessage());
                                err.setErrorType(error.getErrorType());
                                err.setCoordinates(Coordinate.parse(error.getCoordinate()));
                                err.setFile(err.getFile());
                                err.setOriginCoordinates(Coordinate.parse(error.getOriginCoordinate()));
                                errorList.add(err);
                        }
                        model.setErrors(errorList.toArray(new Error[0]));
                }

                Sqlflow sqlflow = MetadataUtil.convertDataflowToMetadata(vendor, dataflow);
                sqlflow.setErrorMessages(null);
                model.setDbobjs(sqlflow);
                model.setOrientation(dataflow.getOrientation());


                List<gudusoft.gsqlparser.dlineage.dataflow.model.json.Process> processes = new ArrayList<gudusoft.gsqlparser.dlineage.dataflow.model.json.Process>();
                if(dataflow.getProcesses()!=null){
                        for(process process: dataflow.getProcesses()){
                                gudusoft.gsqlparser.dlineage.dataflow.model.json.Process processModel = new gudusoft.gsqlparser.dlineage.dataflow.model.json.Process();
                                processModel.setId(process.getId());
                                processModel.setName(process.getName());
                                processModel.setProcedureId(process.getProcedureId());
                                processModel.setProcedureName(process.getProcedureName());
                                processModel.setType(process.getType());
                                processModel.setCoordinate(process.getCoordinate());
                                processModel.setDatabase(process.getDatabase());
                                processModel.setSchema(process.getSchema());
                                processModel.setServer(process.getServer());
                                processModel.setQueryHashId(process.getQueryHashId());
                                if (process.getTransforms() != null && !process.getTransforms().isEmpty()) {
                                        List<gudusoft.gsqlparser.dlineage.dataflow.model.json.Transform> transforms = new ArrayList<gudusoft.gsqlparser.dlineage.dataflow.model.json.Transform>();
                                        for (transform transform : process.getTransforms()) {
                                                gudusoft.gsqlparser.dlineage.dataflow.model.json.Transform item = new gudusoft.gsqlparser.dlineage.dataflow.model.json.Transform();
                                                item.setCode(transform.getCode());
                                                item.setType(transform.getType());
                                                item.setCoordinate(transform.getCoordinate(true));
                                                transforms.add(item);
                                        }
                                        processModel.setTransforms(transforms
                                                        .toArray(new gudusoft.gsqlparser.dlineage.dataflow.model.json.Transform[0]));
                                }
                                processes.add(processModel);
                        }
                }
                model.setProcesses(processes.toArray(new gudusoft.gsqlparser.dlineage.dataflow.model.json.Process[0]));

                Map<String, String> tableIdToProcedureId = new HashMap<>();
                if (dataflow.getTables() != null) {
                        for (table t : dataflow.getTables()) {
                                if (t.getProcedureId() != null) {
                                        tableIdToProcedureId.put(t.getId(), t.getProcedureId());
                                }
                        }
                }

                List<gudusoft.gsqlparser.dlineage.dataflow.model.json.Relationship> relations = new ArrayList<gudusoft.gsqlparser.dlineage.dataflow.model.json.Relationship>();
                if (dataflow.getRelationships() != null) {
                        for (relationship relation : dataflow.getRelationships()) {
                                gudusoft.gsqlparser.dlineage.dataflow.model.json.Relationship relationModel;
                                if (relation.getType().equals("join")) {
                                        gudusoft.gsqlparser.dlineage.dataflow.model.json.JoinRelationship joinRelationModel = new gudusoft.gsqlparser.dlineage.dataflow.model.json.JoinRelationship();
                                        joinRelationModel.setCondition(relation.getCondition());
                                        joinRelationModel.setJoinType(relation.getJoinType());
                                        joinRelationModel.setClause(relation.getClause());
                                        relationModel = joinRelationModel;
                                } else {
                                        relationModel = new gudusoft.gsqlparser.dlineage.dataflow.model.json.Relationship();
                                }

                                relationModel.setId(relation.getId());
                                relationModel.setProcessId(relation.getProcessId());
                                relationModel.setProcessType(relation.getProcessType());
                                relationModel.setType(relation.getType());
                                relationModel.setEffectType(relation.getEffectType());
                                relationModel.setPartition(relation.getPartition());
                                relationModel.setFunction(relation.getFunction());
                                relationModel.setProcedureId(relation.getProcedureId());
                                relationModel.setSqlHash(relation.getSqlHash());
                                relationModel.setCondition(relation.getCondition());
                                relationModel.setSqlComment(relation.getSqlComment());
                                relationModel.setTimestampMax(relation.getTimestampMax());
                                relationModel.setTimestampMin(relation.getTimestampMin());
                                if (Boolean.TRUE.equals(relation.getBuiltIn())) {
                                        relationModel.setBuiltIn(relation.getBuiltIn());
                                }
                                relationModel.setCallStmt(relation.getCallStmt());
                                relationModel.setCallCoordinate(relation.getCallCoordinate());
                                
                                if (relation.getTarget() != null && relation.getSources() != null && !relation.getSources().isEmpty()) {
                                        {
                                                gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement targetModel = new gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement();
                                                targetColumn target = relation.getTarget();
                                                if (normalizeIdentifier) {
                                                        targetModel.setColumn(LegacyDlineageWireNamesV1.columnName(vendor, target.getColumn()));
                                                        targetModel.setParentName(
                                                                        LegacyDlineageWireNamesV1.tableName(vendor, target.getParent_name()));
                                                        targetModel.setTargetName(
                                                                        LegacyDlineageWireNamesV1.columnName(vendor, target.getTarget_name()));
                                                } else {
                                                        targetModel.setColumn(target.getColumn());
                                                        targetModel.setParentName(target.getParent_name());
                                                        targetModel.setTargetName(target.getTarget_name());
                                                }
                                                targetModel.setId(target.getId());
                                                targetModel.setTargetId(target.getTarget_id());
                                                targetModel.setParentId(target.getParent_id());
                                                targetModel.setCoordinates(Coordinate.parse(target.getCoordinate()));
                                                targetModel.setFunction(target.getFunction());
                                                targetModel.setType(target.getType());
                                                String targetProcId = tableIdToProcedureId.get(target.getParent_id());
                                                if (targetProcId != null) {
                                                        targetModel.setProcedureId(targetProcId);
                                                }
                                                relationModel.setTarget(targetModel);
                                        }

                                        List<gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement> sourceModels = new ArrayList<gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement>();
                                        for (sourceColumn source : relation.getSources()) {
                                                gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement sourceModel = new gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement();
                                                if (normalizeIdentifier) {
                                                        sourceModel.setColumn(LegacyDlineageWireNamesV1.columnName(vendor, source.getColumn()));
                                                        sourceModel.setParentName(
                                                                        LegacyDlineageWireNamesV1.tableName(vendor, source.getParent_name()));
                                                        sourceModel.setSourceName(
                                                                        LegacyDlineageWireNamesV1.columnName(vendor, source.getSource_name()));
                                                } else {
                                                        sourceModel.setColumn(source.getColumn());
                                                        sourceModel.setParentName(source.getParent_name());
                                                        sourceModel.setSourceName(source.getSource_name());
                                                }
                                                sourceModel.setColumnType(source.getColumn_type());
                                                sourceModel.setId(source.getId());
                                                sourceModel.setParentId(source.getParent_id());
                                                sourceModel.setSourceId(source.getSource_id());
                                                sourceModel.setCoordinates(Coordinate.parse(source.getCoordinate()));
                                                sourceModel.setClauseType(source.getClauseType());
                                                sourceModel.setType(source.getType());
                                                String sourceProcId = tableIdToProcedureId.get(source.getParent_id());
                                                if (sourceProcId != null) {
                                                        sourceModel.setProcedureId(sourceProcId);
                                                }
                                                sourceModels.add(sourceModel);
                                                if (source.getTransforms() != null && !source.getTransforms().isEmpty()) {
                                                        List<gudusoft.gsqlparser.dlineage.dataflow.model.json.Transform> transforms = new ArrayList<gudusoft.gsqlparser.dlineage.dataflow.model.json.Transform>();
                                                        for (transform transform : source.getTransforms()) {
                                                                gudusoft.gsqlparser.dlineage.dataflow.model.json.Transform item = new gudusoft.gsqlparser.dlineage.dataflow.model.json.Transform();
                                                                item.setCode(transform.getCode());
                                                                item.setType(transform.getType());
                                                                item.setCoordinate(transform.getCoordinate(true));
                                                                transforms.add(item);
                                                        }
                                                        sourceModel.setTransforms(transforms
                                                                        .toArray(new gudusoft.gsqlparser.dlineage.dataflow.model.json.Transform[0]));
                                                }
                                                
                                                if (source.getCandidateParents() != null && !source.getCandidateParents().isEmpty()) {
                                                        List<gudusoft.gsqlparser.dlineage.dataflow.model.json.CandidateTable> candidateParents = new ArrayList<gudusoft.gsqlparser.dlineage.dataflow.model.json.CandidateTable>();
                                                        for (candidateTable candidateTable : source.getCandidateParents()) {
                                                                gudusoft.gsqlparser.dlineage.dataflow.model.json.CandidateTable item = new gudusoft.gsqlparser.dlineage.dataflow.model.json.CandidateTable();
                                                                item.setId(candidateTable.getId());
                                                                if (normalizeIdentifier) {
                                                                        item.setName(
                                                                                        LegacyDlineageWireNamesV1.tableName(vendor, candidateTable.getName()));
                                                                } else {
                                                                        item.setName(candidateTable.getName());
                                                                }
                                                                candidateParents.add(item);
                                                        }
                                                        sourceModel.setCandidateParents(candidateParents
                                                                        .toArray(new gudusoft.gsqlparser.dlineage.dataflow.model.json.CandidateTable[0]));
                                                }
                                        }
                                        relationModel.setSources(sourceModels
                                                        .toArray(new gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement[0]));
                                        relations.add(relationModel);
                                } else if (relation.getCaller() != null && relation.getCallees() != null
                                                && !relation.getCallees().isEmpty()) {
                                        {
                                                gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement targetModel = new gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement();
                                                targetColumn target = relation.getCaller();
                                                if (normalizeIdentifier) {
                                                        targetModel.setName(LegacyDlineageWireNamesV1.columnName(vendor, target.getName()));
                                                } else {
                                                        targetModel.setName(target.getName());
                                                }
                                                targetModel.setId(target.getId());
                                                targetModel.setCoordinates(Coordinate.parse(target.getCoordinate()));
                                                targetModel.setType(target.getType());
                                                relationModel.setCaller(targetModel);
                                        }

                                        List<gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement> sourceModels = new ArrayList<gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement>();
                                        for (sourceColumn source : relation.getCallees()) {
                                                gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement sourceModel = new gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement();
                                                if (normalizeIdentifier) {
                                                        sourceModel.setName(LegacyDlineageWireNamesV1.columnName(vendor, source.getName()));
                                                } else {
                                                        sourceModel.setName(source.getName());
                                                }
                                                sourceModel.setId(source.getId());
                                                sourceModel.setCoordinates(Coordinate.parse(source.getCoordinate()));
                                                sourceModel.setType(source.getType());
                                                sourceModels.add(sourceModel);
                                        }
                                        relationModel.setCallees(sourceModels
                                                        .toArray(new gudusoft.gsqlparser.dlineage.dataflow.model.json.RelationshipElement[0]));
                                        relations.add(relationModel);
                                }
                        }
                }
                model.setRelationships(relations.toArray(new gudusoft.gsqlparser.dlineage.dataflow.model.json.Relationship[0]));
                return model;
        }

        public static String getVersion() {
                // Return the authoritative product version instead of a stale hardcoded
                // constant so version-reporting stays in sync with each release (MantisBT
                // / QS-009). TBaseType.versionid is the single source of truth (also used
                // by the JAR manifest and release notes).
                return TBaseType.versionid;
        }

        public static String getReleaseDate() {
                return TBaseType.releaseDate;
        }

        public static void main(String[] args) {
                if (args.length < 1) {
                        System.out.println(
                                        "Usage: java DataFlowAnalyzer [/f <path_to_sql_file>] [/d <path_to_directory_includes_sql_files>] [/s [/text]] [/json] [/traceView] [/t <database type>] [/o <output file path>][/version]");
                        System.out.println("/f: Option, specify the sql file path to analyze fdd relation.");
                        System.out.println("/d: Option, specify the sql directory path to analyze fdd relation.");
                        System.out.println("/j: Option, analyze the join relation.");
                        System.out.println("/s: Option, simple output, ignore the intermediate results.");
                        System.out.println("/i: Option, ignore all result sets.");
                        System.out.println("/traceView: Option, analyze the source tables of views.");
                        System.out.println("/text: Option, print the plain text format output.");
                        System.out.println("/json: Option, print the json format output.");
                        System.out.println(
                                        "/t: Option, set the database type. Support oracle, mysql, mssql, db2, netezza, teradata, informix, sybase, postgresql, hive, greenplum and redshift, the default type is oracle");
                        System.out.println("/o: Option, write the output stream to the specified file.");
                        System.out.println("/log: Option, generate a dataflow.log file to log information.");
                        return;
                }

                File sqlFiles = null;

                List<String> argList = Arrays.asList(args);

                if (argList.indexOf("/version") != -1) {
                        System.out.println("Version: " + DataFlowAnalyzer.getVersion());
                        System.out.println("Release Date: " + DataFlowAnalyzer.getReleaseDate());
                        return;
                }

                if (argList.indexOf("/f") != -1 && argList.size() > argList.indexOf("/f") + 1) {
                        sqlFiles = new File(args[argList.indexOf("/f") + 1]);
                        if (!sqlFiles.exists() || !sqlFiles.isFile()) {
                                System.out.println(sqlFiles + " is not a valid file.");
                                return;
                        }
                } else if (argList.indexOf("/d") != -1 && argList.size() > argList.indexOf("/d") + 1) {
                        sqlFiles = new File(args[argList.indexOf("/d") + 1]);
                        if (!sqlFiles.exists() || !sqlFiles.isDirectory()) {
                                System.out.println(sqlFiles + " is not a valid directory.");
                                return;
                        }
                } else {
                        System.out.println("Please specify a sql file path or directory path to analyze dlineage.");
                        return;
                }

                EDbVendor vendor = EDbVendor.dbvoracle;

                int index = argList.indexOf("/t");

                if (index != -1 && args.length > index + 1) {
                        vendor = TGSqlParser.getDBVendorByName(args[index + 1]);
                }

                String outputFile = null;

                index = argList.indexOf("/o");

                if (index != -1 && args.length > index + 1) {
                        outputFile = args[index + 1];
                }

                FileOutputStream writer = null;
                if (outputFile != null) {
                        try {
                                writer = new FileOutputStream(outputFile);
                                System.setOut(new PrintStream(writer));
                        } catch (FileNotFoundException e) {
                                logger.error("output file is not found.", e);
                        }
                }

                boolean simple = argList.indexOf("/s") != -1;
                boolean ignoreResultSets = argList.indexOf("/i") != -1;
                boolean showJoin = argList.indexOf("/j") != -1;
                boolean textFormat = false;
                boolean jsonFormat = false;
                if (simple) {
                        textFormat = argList.indexOf("/text") != -1;
                }

                boolean traceView = argList.indexOf("/traceView") != -1;
                if (traceView) {
                        simple = true;
                }

                jsonFormat = argList.indexOf("/json") != -1;

                DataFlowAnalyzer dlineage = new DataFlowAnalyzer(sqlFiles, vendor, simple);

                dlineage.setShowJoin(showJoin);
                dlineage.setIgnoreRecordSet(ignoreResultSets);
                // dlineage.setShowImplicitSchema(true);

                if (simple && !jsonFormat) {
                        dlineage.setTextFormat(textFormat);
                }

                String result = dlineage.generateDataFlow();

//              dataflow dataflow = ProcessUtility.generateTableLevelLineage(dlineage, dlineage.getDataFlow());
//              System.out.println(result);

                if (jsonFormat) {
                        // Map jsonResult = new LinkedHashMap();
                        Dataflow model = getSqlflowJSONModel(vendor, dlineage.getDataFlow(), true);
                        // jsonResult.put("data", BeanUtils.bean2Map(model));
                        result = JSON.toJSONString(model);
                } else if (traceView) {
                        result = dlineage.traceView();
                }

                if (result != null) {
                        System.out.println(result);

                        if (writer != null && result.length() < 1024 * 1024) {
                                System.err.println(result);
                        }
                }

                try {
                        if (writer != null) {
                                writer.close();
                        }
                } catch (IOException e) {
                        logger.error("close writer failed.", e);
                }

                boolean log = argList.indexOf("/log") != -1;

                PrintStream systemSteam = System.err;
                ByteArrayOutputStream sw = new ByteArrayOutputStream();
                PrintStream pw = new PrintStream(sw);
                System.setErr(pw);


                List<ErrorInfo> errors = dlineage.getErrorMessages();
                if (!errors.isEmpty()) {
                        System.err.println("Error log:\n");
                        for (int i = 0; i < errors.size(); i++) {
                                System.err.println(errors.get(i).getErrorMessage());
                        }
                }

                if (sw != null) {
                        String errorMessage = sw.toString().trim();
                        if (errorMessage.length() > 0) {
                                if (log) {
                                        try {
                                                pw = new PrintStream(new File(".", "dataflow.log"));
                                                pw.print(errorMessage);
                                        } catch (FileNotFoundException e) {
                                                logger.error("error log file is not found.", e);
                                        }
                                }

                                System.setErr(systemSteam);
                                System.err.println(errorMessage);
                        }
                }
        }

        public List<ErrorInfo> getErrorMessages() {
                return errorInfos;
        }

        /**
         * Every dynamic-SQL execution site (T-SQL {@code EXEC(...)} / {@code sp_executesql}) the analyzer
         * encountered, with whether it was statically resolved. Diagnostic only; not consumed by lineage.
         * Read-only snapshot; see {@link DynamicSqlSite}.
         */
        public List<DynamicSqlSite> getDynamicSqlSites() {
                return java.util.Collections.unmodifiableList(new ArrayList<DynamicSqlSite>(dynamicSqlSites));
        }

        /**
         * Resolve dynamic-SQL object names by abstractly evaluating a stored procedure
         * with a set of parameter bindings.
         *
         * <p>Given a T-SQL {@code CREATE PROC} parse tree and the values its parameters
         * actually had at a call site (e.g. {@code @SourceDB='QSP'},
         * {@code @STG_AEG='STG_AEG'}), this evaluates the procedure's dynamic-SQL string
         * building (assignment + concatenation + name-building functions), materializes
         * the concrete SQL each {@code EXEC} / {@code sp_executesql} site runs, analyzes
         * it with ordinary dlineage, and returns the lineage edges tagged with dynamic
         * provenance ({@code origin=DYNAMIC_RESOLVED}, source proc, stable dynamic-site
         * id, binding hash). Sites that cannot be reduced are reported as honest
         * {@code UNRESOLVED} diagnostics — never guessed.
         *
         * <p>This is abstract string evaluation, NOT execution: no table reads, no
         * cursors, no data-dependent control flow. It is purely additive — it builds
         * throwaway analyzers for the materialized strings and does not change the
         * default dlineage output of this analyzer.
         *
         * @param procAst         the {@code CREATE PROC} parse tree (currently T-SQL)
         * @param vendor          the SQL dialect ({@code dbvmssql})
         * @param sqlEnv          catalog env for the resolved analysis (may be null)
         * @param currentDatabase the proc's database (resolves unqualified names)
         * @param defaultSchema   the proc's default schema (e.g. {@code dbo})
         * @param bindings        parameter name → concrete value
         * @param options         resource bounds (may be null for defaults)
         */
        public gudusoft.gsqlparser.dlineage.dynamicsql.DynamicLineageResult resolveDynamicSqlLineage(
                        TCustomSqlStatement procAst, EDbVendor vendor, gudusoft.gsqlparser.sqlenv.TSQLEnv sqlEnv,
                        String currentDatabase, String defaultSchema,
                        Map<String, gudusoft.gsqlparser.dlineage.dynamicsql.SqlValue> bindings,
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicLineageOptions options) {
                return gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.resolve(
                                procAst, vendor, sqlEnv, currentDatabase, defaultSchema, bindings, options);
        }

        public String traceView() {
                StringBuilder buffer = new StringBuilder();
                dataflow dataflow = this.getDataFlow();
                Map<table, Set<table>> traceViewMap = new LinkedHashMap<table, Set<table>>();
                if (dataflow != null && dataflow.getViews() != null) {
                        List<relationship> relations = dataflow.getRelationships();
                        Map<String, table> viewMap = new HashMap<String, table>();
                        Map<String, table> tableMap = new HashMap<String, table>();
                        for (table view : dataflow.getViews()) {
                                viewMap.put(view.getId(), view);
                                tableMap.put(view.getId(), view);
                        }
                        for (table table : dataflow.getTables()) {
                                tableMap.put(table.getId(), table);
                        }
                        for (relationship relation : relations) {
                                if (!RelationshipType.fdd.name().equals(relation.getType())) {
                                        continue;
                                }
                                String parentId = relation.getTarget().getParent_id();
                                if (viewMap.containsKey(parentId)) {
                                        if (!traceViewMap.containsKey(viewMap.get(parentId))) {
                                                traceViewMap.put(viewMap.get(parentId), new LinkedHashSet<table>());
                                        }

                                        for (sourceColumn sourceColumn : relation.getSources()) {
                                                traceViewMap.get(viewMap.get(parentId)).add(tableMap.get(sourceColumn.getParent_id()));
                                        }
                                }
                        }

                        Map<table, Set<table>> viewTableMap = new LinkedHashMap<table, Set<table>>();
                        for (table view : traceViewMap.keySet()) {
                                Set<table> tables = new LinkedHashSet<table>();
                                traverseViewSourceTables(tables, view, traceViewMap);
                                viewTableMap.put(view, tables);
                        }

                        for (table view : viewTableMap.keySet()) {
                                buffer.append(view.getFullName());
                                for (table table : viewTableMap.get(view)) {
                                        buffer.append(",").append(table.getFullName());
                                }
                                buffer.append(System.getProperty("line.separator"));
                        }
                }
                return buffer.toString().trim();
        }

        private void traverseViewSourceTables(Set<table> tables, table view, Map<table, Set<table>> traceViewMap) {
                Set<table> sourceTables = traceViewMap.get(view);
                for (table sourceTable : sourceTables) {
                        if (sourceTable.isTable()) {
                                tables.add(sourceTable);
                        } else if (sourceTable.isView()) {
                                traverseViewSourceTables(tables, sourceTable, traceViewMap);
                        }
                }
        }

        protected List<SqlInfo> convertSQL(EDbVendor vendor, String json) {
                List<SqlInfo> sqlInfos = new ArrayList<SqlInfo>();
                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("{")) {
                                if (sql.indexOf("createdBy") != -1) {
                                        String shardBaseDir = filePath != null ? new File(filePath).getParent() : null;
                                        // Route on the authoritative `format` first. A sqlflow-sharded
                                        // manifest carries the product brand (SQLdep/grabit) in createdBy
                                        // but has no single-file `queries` array — reading it through the
                                        // brand path silently dropped every source record.
                                        if (MetadataReader.isSqlflowSharded(sql)) {
                                                if (MetadataReader.isSupportedSqlflowSharded(sql)) {
                                                        appendShardedSourceSqlInfos(sql, shardBaseDir, fileName, sqlInfos);
                                                }
                                                // Unsupported version, or no base dir to locate shards:
                                                // nothing is added — never misrouted, never crashes.
                                        } else if (sql.toLowerCase(Locale.ROOT).indexOf("sqldep") != -1
                                                        || sql.toLowerCase(Locale.ROOT).indexOf("grabit") != -1) {
                                                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);
                                                        }
                                                        queryObject.remove("queries");
                                                        SqlInfo info = new SqlInfo();
                                                        info.setSql(JSON.toJSONString(queryObject));
                                                        info.setFileName(fileName);
                                                        info.setFilePath(filePath);
                                                        info.setOriginIndex(querys.size());
                                                        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.toLowerCase(Locale.ROOT).indexOf("sqlflow") != -1) {
                                                Map sqlflow = (Map) JSON.parseObject(sql);
                                                List<Map> servers = (List<Map>) sqlflow.get("servers");
                                                if (servers != null) {
                                                        for (Map queryObject : servers) {
                                                                String name = (String) queryObject.get("name");
                                                                String dbVendor = (String) queryObject.get("dbVendor");
                                                                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);
                                                                                info.setDbVendor(dbVendor);
                                                                                info.setServer(name);
                                                                                sqlInfos.add(info);
                                                                        }
                                                                        queryObject.remove("queries");
                                                                        Map serverObject = new IndexedLinkedHashMap();
                                                                        serverObject.put("createdBy", sqlflow.get("createdBy"));
                                                                        serverObject.put("servers", Arrays.asList(queryObject));
                                                                        SqlInfo info = new SqlInfo();
                                                                        info.setSql(JSON.toJSONString(serverObject));
                                                                        info.setFileName(fileName);
                                                                        info.setFilePath(filePath);
                                                                        info.setOriginIndex(querys.size());
                                                                        info.setDbVendor(dbVendor);
                                                                        info.setServer(filePath);
                                                                        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);
                                                                }
                                                        }
                                                }
                                                
                                                List<Map> errorMessages =  (List<Map>) sqlflow.get("errorMessages");
                                                if(errorMessages!=null && !errorMessages.isEmpty()) {
                                                        for(Map error: errorMessages){
                                                                ErrorInfo errorInfo = new ErrorInfo();
                                                                errorInfo.setErrorType(ErrorInfo.METADATA_ERROR);
                                                                errorInfo.setErrorMessage((String)error.get("errorMessage"));
                                                                errorInfo.setFileName(fileName);
                                                                errorInfo.setFilePath(filePath);
                                                                errorInfo.setStartPosition(new Pair3<Long, Long, String>(-1L, -1L,
                                                                                ModelBindingManager.getGlobalHash()));
                                                                errorInfo.setEndPosition(new Pair3<Long, Long, String>(-1L, -1L,
                                                                                ModelBindingManager.getGlobalHash()));
                                                                errorInfo.setOriginStartPosition(new Pair<Long, Long>(-1L, -1L));
                                                                errorInfo.setOriginEndPosition(new Pair<Long, Long>(-1L, -1L));
                                                                metadataErrors.add(errorInfo);
                                                        }
                                                }
                                        }
                                }
                        } else if (sql != null) {
                                SqlInfo info = new SqlInfo();
                                info.setSql(sql);
                info.setSourceOriginKind((String)sqlContent.get("sourceOriginKind"));
                                info.setFileName(fileName);
                                info.setFilePath(filePath);
                                info.setOriginIndex(0);
                                sqlInfos.add(info);
                        } else if (filePath != null) {
                                SqlInfo info = new SqlInfo();
                                info.setFileName(fileName);
                                info.setFilePath(filePath);
                                info.setOriginIndex(0);
                                sqlInfos.add(info);
                        }
                }
                return sqlInfos;
        }

        public void setTextFormat(boolean textFormat) {
                option.setTextFormat(textFormat);
        }

        public boolean isBuiltInFunctionName(TObjectName object) {
                if (object == null || object.getGsqlparser() == null)
                        return false;
                try {
                        EDbVendor vendor = object.getGsqlparser().getDbVendor();
                        if (vendor == EDbVendor.dbvteradata) {
                                boolean result = TERADATA_BUILTIN_FUNCTIONS.contains(object.toString().toUpperCase(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++) {
                                        boolean result = functionChecker.isBuiltInFunction(object.toString(),
                                                        object.getGsqlparser().getDbVendor(), 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 boolean isBuiltInFunctionName(String functionName) {
                if (functionName == null)
                        return false;
                try {
                        EDbVendor vendor = getOption().getVendor();
                        if (vendor == EDbVendor.dbvteradata) {
                                boolean result = TERADATA_BUILTIN_FUNCTIONS.contains(functionName.toUpperCase(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 boolean isKeyword(TObjectName object) {
                if (object == null || object.getGsqlparser() == null)
                        return false;
                try {
                        EDbVendor vendor = object.getGsqlparser().getDbVendor();

                        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(object.toString());
                                        boolean result = keywordChecker.isKeyword(segments.get(segments.size() - 1),
                                                        object.getGsqlparser().getDbVendor(), versions.get(i), true);
                                        if (result) {
                                                return result;
                                        }
                                }
                        }
                } catch (Exception e) {
                }

                return false;
        }
        
        public boolean isKeyword(String objectName) {
                if (objectName == null)
                        return false;
                try {
                        EDbVendor vendor = getOption().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 boolean isAggregateFunction(TFunctionCall func) {
                if (func == null)
                        return false;
                String name = builtInFunctionName(func);
                return Arrays
                                .asList(new String[] { "AVG", "COUNT", "MAX", "MIN", "SUM", "COLLECT", "CORR", "COVAR_POP",
                                                "COVAR_SAMP", "CUME_DIST", "DENSE_RANK", "FIRST", "GROUP_ID", "GROUPING", "GROUPING_ID", "LAST",
                                                "LISTAGG", "MEDIAN", "PERCENT_RANK", "PERCENTILE_CONT", "PERCENTILE_DISC", "RANK",
                                                "STATS_BINOMIAL_TEST", "STATS_CROSSTAB", "STATS_F_TEST", "STATS_KS_TEST", "STATS_MODE",
                                                "STATS_MW_TEST", "STATS_ONE_WAY_ANOVA", "STATS_WSR_TEST", "STDDEV", "STDDEV_POP", "STDDEV_SAMP",
                                                "SYS_XMLAGG", "VAR_ POP", "VAR_ SAMP", "VARI ANCE", "XMLAGG", "ARRAY_AGG" })
                                .contains(name.toUpperCase(Locale.ROOT));
        }

        /**
         * The name a call is compared with built-in function names by: TD_SYSFNLIB.XMLAGG is Teradata's XMLAGG, as the
         * system function library names the built-in (Mantis 4921); any other qualified name stays a user function's.
         */
        private String builtInFunctionName(TFunctionCall func) {
                TObjectName functionName = func.getFunctionName();
                return isTeradataSystemFunction(functionName) ? functionName.getObjectString() : functionName.toString();
        }

        private boolean isTeradataSystemFunction(TObjectName functionName) {
                return option.getVendor() == EDbVendor.dbvteradata && functionName.getSchemaString() != null
                                && functionName.getObjectString() != null
                                && DlineageUtil.sameName(ESQLDataObjectType.dotSchema, functionName.getSchemaString(), "TD_SYSFNLIB");
        }

        public boolean isConstant(TObjectName object) {
                if (object == null || object.getGsqlparser() == null)
                        return false;
                List<String> constants = Arrays.asList(new String[] { "NEXTVAL", "CURRVAL", "SYSDATE", "CENTURY", "YEAR",
                                "MONTH", "DAY", "HOUR", "MINUTE", "SECOND" });
                List<String> segments = SQLUtil.parseNames(object.toString());
                // sequence.NEXTVAL or sequence.CURRVAL is a sequence reference, not a constant
                // This syntax is used by Oracle, Snowflake, and accepted by other vendors for compatibility
                String columnNameOnly = object.getColumnNameOnly();
                if (segments.size() > 1 && ("NEXTVAL".equalsIgnoreCase(columnNameOnly) || "CURRVAL".equalsIgnoreCase(columnNameOnly))) {
                        return false;
                }
                boolean result = constants.indexOf(segments.get(segments.size() - 1).toUpperCase(Locale.ROOT)) != -1;
                if (result) {
                        return result;
                }
                if (isKeyword(object)) {
                        return true;
                }
                return false;
        }

        private Pair3<Long, Long, Integer> convertCoordinate(Pair3<Long, Long, String> position) {
//              if (ModelBindingManager.getGlobalOption()!=null && ModelBindingManager.getGlobalOption().isIgnoreCoordinate()) {
//                      return new Pair3<>(-1L, -1L, -1);
//              }
                return new Pair3<Long, Long, Integer>(position.first, position.second,
                                ModelBindingManager.getGlobalSqlInfo().getIndexOf(position.third));
        }

        /**
         * Analyze MDX SELECT statement to generate data lineage.
         * Maps MDX cube as source table, measures/dimensions as columns,
         * and creates dataflow relationships to the result set.
         */
        private void analyzeMdxSelectStmt(gudusoft.gsqlparser.stmt.mdx.TMdxSelect stmt) {
                // Get cube name from FROM clause
                gudusoft.gsqlparser.nodes.mdx.TMdxIdentifierNode cube = stmt.getCube();
                if (cube == null) {
                        return;
                }

                String cubeName = getMdxIdentifierName(cube);
                Table cubeTable = modelFactory.createTableByName(cubeName, false);

                // Collect all MDX identifier references from axes and WHERE clause
                List<String> measureNames = new ArrayList<String>();
                List<String> dimensionNames = new ArrayList<String>();

                // Process axes (COLUMNS, ROWS, etc.)
                if (stmt.getAxes() != null) {
                        for (int i = 0; i < stmt.getAxes().size(); i++) {
                                gudusoft.gsqlparser.nodes.mdx.TMdxAxisNode axis = stmt.getAxes().getElement(i);
                                if (axis.getExpNode() != null) {
                                        collectMdxReferences(axis.getExpNode(), measureNames, dimensionNames);
                                }
                        }
                }

                // Process WHERE clause (slicer dimension)
                if (stmt.getWhere() != null && stmt.getWhere().getFilter() != null) {
                        collectMdxReferences(stmt.getWhere().getFilter(), measureNames, dimensionNames);
                }

                // Process WITH MEMBER definitions
                if (stmt.getWiths() != null) {
                        for (int i = 0; i < stmt.getWiths().size(); i++) {
                                gudusoft.gsqlparser.nodes.mdx.TMdxWithNode withNode = stmt.getWiths().getElement(i);
                                if (withNode.getNameNode() != null) {
                                        String withName = getMdxIdentifierName(withNode.getNameNode());
                                        // Calculated members are treated as derived measures
                                        if (withName.toLowerCase(Locale.ROOT).startsWith("[measures].")
                                                        || withName.toLowerCase(Locale.ROOT).startsWith("measures.")) {
                                                measureNames.add(withName);
                                        }
                                }
                                // Also collect references used in the WITH expression
                                if (withNode.getExprNode() != null) {
                                        collectMdxReferences(withNode.getExprNode(), measureNames, dimensionNames);
                                }
                        }
                }

                // Create columns on the cube table for all referenced measures and dimensions
                Set<String> addedColumns = new LinkedHashSet<String>();
                for (String measure : measureNames) {
                        if (addedColumns.add(measure)) {
                                modelFactory.createTableColumn(cubeTable, measure);
                        }
                }
                for (String dimension : dimensionNames) {
                        if (addedColumns.add(dimension)) {
                                modelFactory.createTableColumn(cubeTable, dimension);
                        }
                }

                // Create result set with all referenced columns
                ResultSet resultSet = modelFactory.createResultSet(stmt, false);
                if (resultSet != null) {
                        for (String colName : addedColumns) {
                                TableColumn sourceCol = findTableColumnByName(cubeTable, colName);
                                if (sourceCol != null) {
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(EffectType.select);
                                        relation.addSource(new TableColumnRelationshipElement(sourceCol));
                                        relation.setTarget(new RelationRowsRelationshipElement<ResultSetRelationRows>(
                                                        resultSet.getRelationRows()));
                                }
                        }
                }
        }

        private TableColumn findTableColumnByName(Table table, String name) {
                for (TableColumn col : table.getColumns()) {
                        if (col.getName().equals(name)) {
                                return col;
                        }
                }
                return null;
        }

        /**
         * Extract the display name from an MDX identifier node.
         * E.g., [Measures].[Departures NEAT] -> [Measures].[Departures NEAT]
         */
        private String getMdxIdentifierName(gudusoft.gsqlparser.nodes.mdx.TMdxIdentifierNode idNode) {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < idNode.getSegmentList().size(); i++) {
                        if (i > 0) sb.append(".");
                        gudusoft.gsqlparser.nodes.mdx.IMdxIdentifierSegment seg = idNode.getSegmentList().getElement(i);
                        if (seg.getQuoting() == gudusoft.gsqlparser.nodes.mdx.EMdxQuoting.QUOTED) {
                                sb.append("[").append(seg.getName()).append("]");
                        } else {
                                sb.append(seg.getName());
                        }
                }
                return sb.toString();
        }

        /**
         * Recursively collect measure and dimension references from MDX expression tree.
         * Uses iterative DFS to avoid StackOverflow on deeply nested expressions.
         */
        private void collectMdxReferences(gudusoft.gsqlparser.nodes.mdx.TMdxExpNode expr,
                        List<String> measures, List<String> dimensions) {
                Deque<gudusoft.gsqlparser.nodes.mdx.TMdxExpNode> stack = new ArrayDeque<gudusoft.gsqlparser.nodes.mdx.TMdxExpNode>();
                stack.push(expr);

                while (!stack.isEmpty()) {
                        gudusoft.gsqlparser.nodes.mdx.TMdxExpNode current = stack.pop();
                        if (current == null) continue;

                        if (current instanceof gudusoft.gsqlparser.nodes.mdx.TMdxIdentifierNode) {
                                gudusoft.gsqlparser.nodes.mdx.TMdxIdentifierNode idNode =
                                                (gudusoft.gsqlparser.nodes.mdx.TMdxIdentifierNode) current;
                                String name = getMdxIdentifierName(idNode);
                                if (name.toLowerCase(Locale.ROOT).startsWith("[measures].")
                                                || name.toLowerCase(Locale.ROOT).startsWith("measures.")) {
                                        measures.add(name);
                                } else if (idNode.getSegmentList().size() > 1) {
                                        // Multi-segment identifiers that aren't measures are dimensions
                                        dimensions.add(name);
                                }
                        } else if (current instanceof gudusoft.gsqlparser.nodes.mdx.TMdxSetNode) {
                                gudusoft.gsqlparser.nodes.mdx.TMdxSetNode setNode =
                                                (gudusoft.gsqlparser.nodes.mdx.TMdxSetNode) current;
                                if (setNode.getTupleList() != null) {
                                        for (int i = 0; i < setNode.getTupleList().size(); i++) {
                                                stack.push(setNode.getTupleList().getElement(i));
                                        }
                                }
                        } else if (current instanceof gudusoft.gsqlparser.nodes.mdx.TMdxTupleNode) {
                                gudusoft.gsqlparser.nodes.mdx.TMdxTupleNode tupleNode =
                                                (gudusoft.gsqlparser.nodes.mdx.TMdxTupleNode) current;
                                if (tupleNode.getExprList() != null) {
                                        for (int i = 0; i < tupleNode.getExprList().size(); i++) {
                                                stack.push(tupleNode.getExprList().getElement(i));
                                        }
                                }
                        } else if (current instanceof gudusoft.gsqlparser.nodes.mdx.TMdxBinOpNode) {
                                gudusoft.gsqlparser.nodes.mdx.TMdxBinOpNode binOp =
                                                (gudusoft.gsqlparser.nodes.mdx.TMdxBinOpNode) current;
                                if (binOp.getRightExprNode() != null) stack.push(binOp.getRightExprNode());
                                if (binOp.getLeftExprNode() != null) stack.push(binOp.getLeftExprNode());
                        } else if (current instanceof gudusoft.gsqlparser.nodes.mdx.TMdxFunctionNode) {
                                gudusoft.gsqlparser.nodes.mdx.TMdxFunctionNode funcNode =
                                                (gudusoft.gsqlparser.nodes.mdx.TMdxFunctionNode) current;
                                if (funcNode.getArguments() != null) {
                                        for (int i = 0; i < funcNode.getArguments().size(); i++) {
                                                stack.push(funcNode.getArguments().getElement(i));
                                        }
                                }
                        }
                }
        }

        /**
         * Analyze a Power Query M-language document for data lineage.
         *
         * Delegates to TPowerQueryAnalyzer to extract navigation chains and
         * NativeQuery embedded SQL, then feeds the results back through the
         * standard SQL analysis pipeline so the dataflow model contains
         * regular table/column lineage.
         */
        private void analyzePowerQueryDocumentStmt(TPowerQueryDocumentStmt pqStmt) {
                TPowerQueryAnalyzer pqAnalyzer = new TPowerQueryAnalyzer(pqStmt);

                if (option.getPowerQueryInnerVendor() != null) {
                        pqAnalyzer.withExplicitInnerVendor(option.getPowerQueryInnerVendor());
                }

                PowerQueryLineageResult result = pqAnalyzer.analyze();

                if (result.isEmpty()) {
                        for (String w : result.getWarnings()) {
                                logger.warn("Power Query: " + w);
                        }
                        return;
                }

                for (PowerQueryLineageResult.NativeQueryRef nq : result.getNativeQueryReferences()) {
                        if (nq.innerParser != null && nq.innerParseReturnCode == 0) {
                                for (int i = 0; i < nq.innerParser.sqlstatements.size(); i++) {
                                        analyzeCustomSqlStmt(nq.innerParser.sqlstatements.get(i));
                                }
                        }
                }

                for (PowerQueryLineageResult.NavigationRef nav : result.getNavigationReferences()) {
                        if (nav.syntheticSelect != null && nav.resolvedVendor != null) {
                                TGSqlParser synParser = createSqlParser(nav.resolvedVendor);
                                synParser.sqltext = nav.syntheticSelect;
                                int rc = synParser.parse();
                                if (rc == 0) {
                                        for (int i = 0; i < synParser.sqlstatements.size(); i++) {
                                                analyzeCustomSqlStmt(synParser.sqlstatements.get(i));
                                        }
                                }
                        }
                }

                for (String w : result.getWarnings()) {
                        logger.warn("Power Query: " + w);
                }
        }


        /**
         * True for an Oracle pseudocolumn that is scoped to one table, i.e. ROWID.
         *
         * <p>These report {@link EDbObjectType#notAColumn} so that nothing resolves
         * them against a catalog that will never contain them, but they still carry
         * a real source table: {@code SELECT a.ROWID AS rn FROM t a} genuinely does
         * derive {@code rn} from a row of {@code t}. Letting the notAColumn branch
         * claim them would route them to constants and delete that edge
         * (Mantis #4675).</p>
         */
        private boolean isTableScopedPseudoColumn(TObjectName object) {
                if (object == null) return false;
                if (object.getDbObjectType() != EDbObjectType.notAColumn) return false;
                if (object.getSourceTable() == null) return false;
                return gudusoft.gsqlparser.util.OraclePseudoColumnUtil
                                .isTableScopedPseudoColumn(object.getColumnNameOnly());
        }

}