package gudusoft.gsqlparser.dlineage;

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.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>();
        private Map<String, TCustomSqlStatement> viewDDLMap = new HashMap<String, TCustomSqlStatement>();
        private Map<String, TCustomSqlStatement> procedureDDLMap = new HashMap<String, TCustomSqlStatement>();
        private Map<TTable, TObjectNameList> structObjectMap = new HashMap<TTable, TObjectNameList>();
        private final Map<String, String> normalizedColumnNameCache = new HashMap<String, String>();
        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 normalized-name -> 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<String, ResultColumn> byNormalizedName;
                ColumnNameIndex(int size, Map<String, ResultColumn> byNormalizedName) {
                        this.size = size;
                        this.byNormalizedName = byNormalizedName;
                }
        }

        /**
         * Return the normalized-name index for {@code columns}, building (and caching) it on first use and
         * rebuilding when the list size changes. Returns an index whose {@code byNormalizedName} is null when
         * the list contains any star ("*") or struct column — signalling the caller to use the linear scan.
         */
        private ColumnNameIndex getColumnNameIndex(List<ResultColumn> columns) {
                ColumnNameIndex idx = columnNameIndexCache.get(columns);
                if (idx != null && idx.size == columns.size()) {
                        return idx;
                }
                Map<String, ResultColumn> map = new HashMap<String, ResultColumn>();
                boolean simple = true;
                for (int i = 0; i < columns.size(); i++) {
                        ResultColumn c = columns.get(i);
                        String nm = c.getName();
                        if ("*".equals(nm) || c.isStruct()) {
                                simple = false;
                                break;
                        }
                        // putIfAbsent semantics: keep the FIRST column for a given normalized name, matching the
                        // linear scan's first-match-wins + break.
                        String key = DlineageUtil.getIdentifierNormalColumnName(nm);
                        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>, Map<String, ResultColumn>> resultSetColumnLookupCache =
                        new java.util.IdentityHashMap<List<ResultColumn>, Map<String, ResultColumn>>();

        private Map<String, ResultColumn> getResultSetColumnLookup(List<ResultColumn> columns) {
                Map<String, ResultColumn> map = resultSetColumnLookupCache.get(columns);
                if (map != null) {
                        return map;
                }
                map = new HashMap<String, ResultColumn>(columns.size() * 2);
                for (ResultColumn c : columns) {
                        String key = DlineageUtil.getIdentifierNormalColumnName(c.getName());
                        if (!map.containsKey(key)) {
                                map.put(key, c);
                        }
                }
                resultSetColumnLookupCache.put(columns, map);
                return map;
        }

        // 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>, Map<String, TableColumn>> tableColumnLookupCache =
                        new java.util.IdentityHashMap<List<TableColumn>, Map<String, TableColumn>>();

        private Map<String, TableColumn> getTableColumnLookup(List<TableColumn> columns) {
                Map<String, TableColumn> map = tableColumnLookupCache.get(columns);
                if (map != null) {
                        return map;
                }
                map = new HashMap<String, TableColumn>(columns.size() * 2);
                for (TableColumn c : columns) {
                        String key = DlineageUtil.getIdentifierNormalColumnName(c.getName());
                        if (!map.containsKey(key)) {
                                map.put(key, c);
                        }
                }
                tableColumnLookupCache.put(columns, map);
                return map;
        }

        private SqlInfo[] sqlInfos;
        private File[] originalFiles;
        private List<ErrorInfo> errorInfos = new ArrayList<ErrorInfo>();
        private final List<DynamicSqlSite> dynamicSqlSites = new ArrayList<DynamicSqlSite>();
        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, List<Map<TCustomSqlStatement, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>>> dynamicEvalCache = new IdentityHashMap<TCustomSqlStatement, List<Map<TCustomSqlStatement, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>>>();
        /**
         * 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;
        private 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 String dataflowString;
        private 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().endsWith(".csv")){
                if(!MetadataReader.isMetadata(info.getSql())){
                    continue;
                }
            }
            else if(children[i].getName().toLowerCase().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);
        }

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

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

        initPipelinedFunctionAnalyzer();

                dataflow = analyzeSqlScript();

                return finishGenerateDataFlow(withExtraInfo);
        }

        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 && !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);
                }

                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<String, List<table>> tableMap = new HashMap<String, List<table>>();
                Map<String, String> tableTypeMap = new HashMap<String, String>();
                Map<String, TMssqlCreateType> mssqlTypeMap = new HashMap<String, TMssqlCreateType>();
                Map<String, String> tableIdMap = new HashMap<String, String>();

                Map<String, List<column>> columnMap = new HashMap<String, List<column>>();
                Map<String, Set<String>> tableColumnMap = new HashMap<String, Set<String>>();
                Map<String, String> columnIdMap = new HashMap<String, String>();
                Map<String, column> columnMergeIdMap = new HashMap<String, column>();

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

                for (table table : tables) {
                        String qualifiedTableName = DlineageUtil.getQualifiedTableName(table);
                        String tableFullName = DlineageUtil.getIdentifierNormalTableName(qualifiedTableName);
                        if ("variable".endsWith(table.getType()) && !SQLUtil.isEmpty(table.getParent())) {
                                tableFullName = table.getParent() + "." + tableFullName;
                        }
                        
                        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<String>());
                                }
                                for (column column : table.getColumns()) {
                                        String columnFullName = tableFullName + "."
                                                        + (column.getQualifiedTable() != null
                                                                        ? (DlineageUtil.getIdentifierNormalTableName(column.getQualifiedTable()) + ".")
                                                                        : "")
                                                        + ("false".equals(table.getIsTarget()) ? DlineageUtil.normalizeColumnName(column.getName())
                                                                        : DlineageUtil.getIdentifierNormalColumnName(column.getName()));

                                        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<String> tableNameIter = tableMap.keySet().iterator();
                while (tableNameIter.hasNext()) {
                        String tableName = tableNameIter.next();
                        List<table> tableList = tableMap.get(tableName);
                        table table;
                        if (tableList.size() > 1) {
                                table standardTable = tableList.get(0);
                                // 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.setServer(standardTable.getServer());
                                table.setDatabase(standardTable.getDatabase());
                                table.setSchema(standardTable.getSchema());
                                table.setName(standardTable.getName());
                                table.setDisplayName(standardTable.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);
                                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<String> columns = tableColumnMap.get(tableName);
                        Iterator<String> columnIter = columns.iterator();
                        List<column> mergeColumns = new ArrayList<column>();
                        while (columnIter.hasNext()) {
                                String 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.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 (dataflow.getRelationships() != null) {
                        Map<Long, relationship> mergeRelations = new LinkedHashMap<Long, 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));
                                        }
                                }

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

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

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

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

                try {
                        dataflow dataflow = new dataflow();
                        
                        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()).parseSQLEnv(option.getVendor(), sqlInfos);
                                        if (sqlenvs != null && sqlenvs.length > 0) {
                                                sqlenv = sqlenvs[0];
                                        }
                                        if (option.getHandleListener() != null) {
                                                option.getHandleListener().endParseSQLEnv();
                                        }
                                }
                                TGSqlParser sqlparser = createSqlParser(option.getVendor());
                                Map<String, Pair3<StringBuilder, AtomicInteger, String>> databaseMap = new LinkedHashMap<String, Pair3<StringBuilder, AtomicInteger, String>>();
                                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(sqlInfos.length == 1){
                                                        dataflow = temp;
                                                }
                                                else {
                                                        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()).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().indexOf("sqldep") != -1
                                                                                        || sql.toLowerCase().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);
                                                                                                appendSqlInfo(databaseMap, j, sqlInfo, queryObject);
                                                                                        }
                                                                                }
                                                                        } else if (sql.toLowerCase().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);
                                                                                                                                        } 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);
                                                                                                                                                                        }
                                                                                                                                                                } 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) {
                                                                                                                for (int j = 0; j < queries.size(); j++) {
                                                                                                                        Map queryObject = queries.get(j);
                                                                                                                        appendSqlInfo(databaseMap, j, sqlInfo, queryObject);
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                }
                                                                                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());

                                                if (sqlInfos.length > 1) {
                                                        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 {
                                                        String sqlHash = SHA256.getMd5(content);
                                                        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;
                                                        if (sqlInfo.getGroup() != null && !sqlInfo.getGroup().isEmpty()) {
                                                                group = sqlInfo.getGroup();
                                                        } 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));
                                                        }
                                                        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);
                                }

                                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) {
                                                sqlenv = new TSQLEnv(option.getVendor()) {

                                                        @Override
                                                        public void initSQLEnv() {
                                                                // TODO Auto-generated method stub

                                                        }
                                                };
                                        }
                                        
                                        String defaultDatabase = null;
                                        String defaultSchema = null;
                                        if(sqlenv!=null){
                                                defaultDatabase = sqlenv.getDefaultCatalogName();
                                                defaultSchema = sqlenv.getDefaultSchemaName();
                                        }
                                        if (supportCatalog && supportSchema) {
                                                if (split.length >= 2) {
                                                        if (!TSQLEnv.DEFAULT_DB_NAME.equals(split[split.length - 2])) {
                                                                ModelBindingManager.setGlobalDatabase(split[split.length - 2]);
                                                                sqlenv.setDefaultCatalogName(ModelBindingManager.getGlobalDatabase());
                                                        }
                                                }
                                                if (split.length >= 1) {
                                                        if (!TSQLEnv.DEFAULT_SCHEMA_NAME.equals(split[split.length - 1])) {
                                                                ModelBindingManager.setGlobalSchema(split[split.length - 1]);
                                                                sqlenv.setDefaultSchemaName(ModelBindingManager.getGlobalSchema());
                                                        }
                                                }
                                        } else if (supportCatalog) {
                                                if (!TSQLEnv.DEFAULT_DB_NAME.equals(split[split.length - 1])) {
                                                        ModelBindingManager.setGlobalDatabase(split[split.length - 1]);
                                                        sqlenv.setDefaultCatalogName(ModelBindingManager.getGlobalDatabase());
                                                }
                                        } else if (supportSchema) {
                                                if (!TSQLEnv.DEFAULT_SCHEMA_NAME.equals(split[split.length - 1])) {
                                                        ModelBindingManager.setGlobalSchema(split[split.length - 1]);
                                                        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));
                                        analyzeAndOutputResult(sqlparser);
                                        if(sqlenv!=null){
                                                sqlenv.setDefaultCatalogName(defaultDatabase);
                                                sqlenv.setDefaultSchemaName(defaultSchema);
                                        }
                                }

                                materializeSqlEnvSynonyms();

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

                        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);
                        }
                        
                        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) {
                Set<String> procedures = new HashSet<String>();
                for (procedure procedure : dataflow.getProcedures()) {
                        procedures.add(DlineageUtil.getIdentifierNormalTableName(procedure.getName()));
                }
                List<table> removeResultSets = new ArrayList<table>();
                
                Map<String, table> allMap = new HashMap<String, table>();
                
                if (dataflow.getResultsets() != null) {
                        for (table t : dataflow.getResultsets()) {
                                allMap.put(t.getId().toLowerCase(), t);
                        }
                }

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

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

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

                
                for (table resultSet : dataflow.getResultsets()) {
                        String resultSetName = DlineageUtil.getIdentifierNormalTableName(resultSet.getName());
                        if (!(ResultSetType.function.name().equals(resultSet.getType())
                                        && modelManager.getFunctionTable(resultSetName) != null && procedures.contains(resultSetName))) {
                                continue;
                        }

                        Set<Object> functionTables = modelManager
                                        .getFunctionTable(DlineageUtil.getIdentifierNormalTableName(resultSet.getName()));
                        List<ResultSet> functionResults = functionTables.stream().filter(t -> t instanceof ResultSet)
                                        .map(t -> (ResultSet) t).collect(Collectors.toList());
                        if (!(resultSet.getColumns().size() == 1
                                        && DlineageUtil.getIdentifierNormalTableName(resultSet.getColumns().get(0).getName()).equals(resultSetName))
                                        || 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 (targetColumn.getColumn().endsWith("*")) {
                                                                        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(DlineageUtil.getIdentifierNormalName(table.getDatabase(), ESQLDataObjectType.dotCatalog));
                        }
                        if(table.getSchema()!=null) {
                                table.setSchema(DlineageUtil.getIdentifierNormalName(table.getSchema(), ESQLDataObjectType.dotSchema));
                        }
                        if(table.getName()!=null) {
                                table.setName(DlineageUtil.getIdentifierNormalName(table.getName(), ESQLDataObjectType.dotTable));
                                idNameMap.put(table.getId(), table.getName());
                        }
                        if(table.getColumns()!=null){
                                for(column column: table.getColumns()){
                                        column.setName(DlineageUtil.getIdentifierNormalName(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(DlineageUtil.getIdentifierNormalName(oraclePackage.getDatabase(), ESQLDataObjectType.dotCatalog));
                                }
                                if(oraclePackage.getSchema()!=null) {
                                        oraclePackage.setSchema(DlineageUtil.getIdentifierNormalName(oraclePackage.getSchema(), ESQLDataObjectType.dotSchema));
                                }
                                if(oraclePackage.getName()!=null) {
                                        oraclePackage.setName(DlineageUtil.getIdentifierNormalName(oraclePackage.getName(), ESQLDataObjectType.dotTable));
                                        idNameMap.put(oraclePackage.getId(), oraclePackage.getName());
                                }
                                if(oraclePackage.getArguments()!=null){
                                        for(argument argument: oraclePackage.getArguments()){
                                                argument.setName(DlineageUtil.getIdentifierNormalName(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(DlineageUtil.getIdentifierNormalName(procedure.getDatabase(), ESQLDataObjectType.dotCatalog));
                                                }
                                                if(procedure.getSchema()!=null) {
                                                        procedure.setSchema(DlineageUtil.getIdentifierNormalName(procedure.getSchema(), ESQLDataObjectType.dotSchema));
                                                }
                                                if(procedure.getName()!=null) {
                                                        procedure.setName(DlineageUtil.getIdentifierNormalName(procedure.getName(), ESQLDataObjectType.dotTable));
                                                        idNameMap.put(procedure.getId(), procedure.getName());
                                                }
                                                for(argument argument: procedure.getArguments()){
                                                        argument.setName(DlineageUtil.getIdentifierNormalName(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(DlineageUtil.getIdentifierNormalName(procedure.getDatabase(), ESQLDataObjectType.dotCatalog));
                                }
                                if(procedure.getSchema()!=null) {
                                        procedure.setSchema(DlineageUtil.getIdentifierNormalName(procedure.getSchema(), ESQLDataObjectType.dotSchema));
                                }
                                if(procedure.getName()!=null) {
                                        procedure.setName(DlineageUtil.getIdentifierNormalName(procedure.getName(), ESQLDataObjectType.dotTable));
                                        idNameMap.put(procedure.getId(), procedure.getName());
                                }
                                for(argument argument: procedure.getArguments()){
                                        argument.setName(DlineageUtil.getIdentifierNormalName(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(DlineageUtil.getIdentifierNormalName(process.getDatabase(), ESQLDataObjectType.dotCatalog));
                                }
                                if(process.getSchema()!=null) {
                                        process.setSchema(DlineageUtil.getIdentifierNormalName(process.getSchema(), ESQLDataObjectType.dotSchema));
                                }
                                if (process.getProcedureId() != null) {
                                        process.setProcedureName(DlineageUtil.getIdentifierNormalName(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);
                        }
                }
        }

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

                                        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
        }

        private void appendSqlInfo(Map<String, Pair3<StringBuilder, AtomicInteger, String>> databaseMap, int index,
                        SqlInfo sqlInfo, Map queryObject) {
                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));
                }
                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;
                }
                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) {
                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);
                                        }
                                } 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();
                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(), t);
                                allMap.put(t.getId().toLowerCase(), 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(), t);
                                allMap.put(t.getId().toLowerCase(), t);
                        }
                }

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

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

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

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

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

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

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

                if (instance.getVariables() != null) {
                        for (table t : instance.getVariables()) {
                                if(SubType.cursor.name().equals(t.getSubType())){
                                        cursorMap.put(t.getId().toLowerCase(), t);
                                }
                                else {
                                        variableMap.put(t.getId().toLowerCase(), t);
                                }
                                allMap.put(t.getId().toLowerCase(), 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;
                        
                        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>>>();
                                        findSourceRelations(target, instance, targetIdRelationMap, relationElem, relationSources,
                                                        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 column = iter.next();
                                                        String relationType = mergeRelationType(columnMap.get(column));
                                                        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 : columnMap.get(column)) {
                                                                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();
                return simple;
        }

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

        private void findStarSourceRelations(targetColumn target, dataflow instance, targetColumn starRelationTarget,
                        Map<String, Set<relationship>> sourceIdRelationMap, relationship targetRelation,
                        List<Pair<sourceColumn, List<String>>> relationSources, String[] pathTypes, Set<String> paths,
                        Set<transform> transforms, Set<candidateTable> candidateTables, int level, boolean simpleOutput) {
                if (targetRelation != null && targetRelation.getSources() != null) {
                        
                        //获取source为*的Column Parent
                        String starParentId = null;
                        for (int i = 0; i < targetRelation.getSources().size(); i++) {
                                sourceColumn source = targetRelation.getSources().get(i);
                                if (starRelationTarget != null && "*".equals(source.getColumn())) {
                                        starParentId = source.getParent_id();
                                }
                        }
                        
                        for (int i = 0; i < targetRelation.getSources().size(); i++) {
                                sourceColumn source = targetRelation.getSources().get(i);
                                if (starRelationTarget != null && !"*".equals(source.getColumn())
                                                && !DlineageUtil.getIdentifierNormalColumnName(starRelationTarget.getColumn())
                                                                .equals(DlineageUtil.getIdentifierNormalColumnName(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;
                                }
                                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);
                                        for (transform t : transforms2) {
                                                sourceColumnCopy.addTransform(t);
                                        }
                                        
                                        for (candidateTable t : candidateTables2) {
                                                sourceColumnCopy.addCandidateParent(t);
                                        }
                                        
                                        if(Boolean.TRUE.equals(target.isStruct()) && Boolean.TRUE.equals(source.isStruct())) {
                                                List<String> targetColumns = SQLUtil.parseNames(target.getColumn());
                                                List<String> sourceColumns = SQLUtil.parseNames(source.getColumn());
                                                if(!DlineageUtil.getIdentifierNormalColumnName(targetColumns.get(targetColumns.size()-1))
                                                                .equals(DlineageUtil.getIdentifierNormalColumnName(sourceColumns.get(sourceColumns.size()-1)))) {
                                                        continue;
                                                }
                                        }
                                        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) {
                                                if (paths.contains(source.getParent_id() + "." + source.getId())) {
                                                        continue;
                                                } else {
                                                        paths.add(source.getParent_id() + "." + source.getId());
                                                        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 (!"*".equals(source.getColumn())) {
                                                                findStarSourceRelations(target, instance, null, sourceIdRelationMap, relation, relationSources,
                                                                                types, paths, transforms2, candidateTables2, level + 1, simpleOutput);
                                                        } else {
                                                                findStarSourceRelations(target, instance,
                                                                                starRelationTarget == null ? targetRelation.getTarget() : starRelationTarget,
                                                                                sourceIdRelationMap, relation, relationSources, types, paths, transforms, candidateTables2,
                                                                                level + 1, simpleOutput);
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        private Map<String, Boolean> targetTables = new HashMap<String, Boolean>();
        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());
                        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())) {
                        table result = resultSetMap.get(targetParent.toLowerCase());
                        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())) {
                        return true;
                }
                return false;
        }

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

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

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

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

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

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

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

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

        private boolean isTable(dataflow instance, String targetParent) {
                if (tableMap.containsKey(targetParent.toLowerCase())) {
                        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() {
                metadataErrors.clear();
                sqlInfoMap.clear();
                errorInfos.clear();
                dynamicSqlSites.clear();
                cteSelectRelationKeys.clear();
                authoritativeEvidenceCollector.reset();
                authoritativeLineageEvidence = AuthoritativeLineageEvidence.empty();
                dynamicEvalCache.clear();
                routineCatalog = null;
                crossFileParseCache.clear();
                plsqlEvaluatedTexts.clear();
                dataflow = null;
                dataflowString = null;
                ModelBindingManager.removeGlobalDatabase();
                ModelBindingManager.removeGlobalSchema();
                ModelBindingManager.removeGlobalVendor();
                ModelBindingManager.removeGlobalSQLEnv();
                ModelBindingManager.removeGlobalHash();
                appendResultSets.clear();
                appendStarColumns.clear();
                appendTableStarColumns.clear();
                normalizedColumnNameCache.clear();
                columnNameIndexCache.clear();
                resultSetColumnLookupCache.clear();
                tableColumnLookupCache.clear();
                modelManager.TABLE_COLUMN_ID = option.getStartId();
                modelManager.RELATION_ID = option.getStartId();
                modelManager.DISPLAY_ID.clear();
                modelManager.DISPLAY_NAME.clear();
                tableIds.clear();
                clickhouseExternalSourceModels.clear();
                ModelBindingManager.setGlobalVendor(option.getVendor());
                modelManager.reset();
        }

        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();
                        procedureDDLMap.clear();
                        structObjectMap.clear();
                        try {
                                if(sqlenv!=null) {
                                        sqlparser.setSqlEnv(sqlenv);
                                }
                                int result = sqlparser.parse();
                                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 = 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);
                                                }
                                        }
                                }

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

                        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.getTableFullName(view.getViewName().toString()), view);
                                                                }
                                                        } else if (stmt instanceof TCreateSynonymStmt) {
                                                                TCreateSynonymStmt synonym = (TCreateSynonymStmt) stmt;
                                                                if(synonym.getSynonymName()!=null) {
                                                                        viewDDLMap.put(DlineageUtil.getTableFullName(synonym.getSynonymName().toString()), synonym);
                                                                }
                                                        } else if (stmt instanceof TStoredProcedureSqlStatement) {
                                                                TStoredProcedureSqlStatement procedure = (TStoredProcedureSqlStatement) stmt;
                                                                if(procedure.getStoredProcedureName() == null) {
                                                                        continue;
                                                                }
                                                                procedureDDLMap.put(DlineageUtil.getProcedureNameWithArgNum(procedure), procedure);
                                                        }
                                                        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) {
                                                        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 TStoredProcedureSqlStatement) {
                                                        boolean listen = false;
                                                        if (option.getHandleListener() != null && !accessedStatements.contains(stmt)) {
                                                                option.getHandleListener().startAnalyzeStatment(stmt);
                                                                listen = true;
                                                        }
                                                        if (stmt instanceof TPlsqlCreateTrigger)
                                                                continue;
                                                        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) && !(stmt instanceof TCreateStageStmt)
                                                                && !(stmt instanceof TCreateExternalDataSourceStmt)
                                                                && !(stmt instanceof TCreateViewSqlStatement) && !(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;
                                                        }
                                                        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);
                                try {
                                        pipelinedAnalyzer.stitchPendingCallSites();
                                } catch (Exception ex) {
                                        // Don't let pipelined stitching failure break main flow
                                } finally {
                                        stmtStack.pop();
                                }
                        }
                } catch (Throwable 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);
                }

        }

        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 void analyzeCustomSqlStmt(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 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);
                                        int result = sqlparser.parse();
                                        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++) {
                                                                analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                                        }
                                                } finally {
                                                        dynamicFoldDepth--;
                                                }
                                        }
                                }
                                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) {
                                        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 = sqlparser.parse();
                                        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;
                                                dynamicFoldDepth++;
                                                try {
                                                        for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                                                analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                                        }
                                                } finally {
                                                        dynamicFoldDepth--;
                                                }
                                        }
                                        // 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, null,
                                                                holeEvidence.fragments, holeEvidence.materializedText);
                                                } 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, null,
                                                                        holeEvidence.fragments, holeEvidence.materializedText);
                                                }
                                        } else {
                                                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, null,
                                                                Collections.<UnresolvedFragment>emptyList(), executeStmt.getSqlText());
                                        }
                                        }
                                } 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) {
                                                // 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 = sqlparser.parse();
                                                        // 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) {
            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);
                                String dataTypeName = param.getDataType().getDataTypeName();
                                TObjectName columnName = param.getParameterName();      
                                TableColumn variableProperty = modelFactory.createTableColumn(variable, columnName, true);
                                if(dataTypeName.indexOf(".")!=-1) {
                                        String tableName = dataTypeName.substring(0, dataTypeName.lastIndexOf("."));
                                        Table table = modelFactory.createTableByName(tableName, true);
                                        if(table!=null) {
                                                TableColumn tableColumn = modelFactory.createInsertTableColumn(table, dataTypeName);
                                                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 = new TObjectName();
                        starColumn.setString("*");
                }
        }
        
        private void analyzePlsqlTableTypeDefStmt(TPlsqlTableTypeDefStmt stmt) {
                TTypeName typeName = stmt.getElementDataType();
                if (typeName != null && typeName.toString().toUpperCase().indexOf("ROWTYPE") != -1) {
                        Variable cursorVariable = modelFactory.createVariable(stmt.getTypeName());
                        cursorVariable.setSubType(SubType.record_type);

                        Table variableTable = modelFactory.createTableByName(typeName.getDataTypeName(), false);
                        if(!variableTable.isCreateTable()) {
                                TObjectName starColumn1 = new TObjectName();
                                starColumn1.setString("*");
                                TableColumn variableTableStarColumn = modelFactory.createTableColumn(variableTable, starColumn1, true);
                                variableTableStarColumn.setShowStar(false);
                                variableTableStarColumn.setExpandStar(true);

                                TObjectName starColumn = new TObjectName();
                                starColumn.setString("*");
                                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().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 = new TObjectName();
                                oldStarColumn.setString("*");
                                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 = new TObjectName();
                                newStarColumn.setString("*");
                                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().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();
                                String procedureNameWithArgSize = module.toString() + "(" + argumentSize + ")";
                                if (argumentSize <= 0  || !DlineageUtil.supportFunctionOverride(option.getVendor())) {
                                        procedureNameWithArgSize = module.toString();
                                }
                                if (procedureDDLMap.containsKey(procedureNameWithArgSize)) {
                                        analyzeCustomSqlStmt(procedureDDLMap.get(procedureNameWithArgSize));
                                }
                                Procedure procedure = modelFactory.createProcedureByName(module, executeStmt.getParameters() == null ? 0 : executeStmt.getParameters().size());
                                String procedureParent = getProcedureParentName(executeStmt);
                                if (procedureParent != null) {
                                        Procedure caller = modelManager
                                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                        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 (procedure.getArguments() != null) {
                                        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);
                                                }
                                        }
                                }
                        }
                }
        }

        private void analyzeDropTableStmt(TDropTableSqlStatement stmt) {
                TTable dropTable = stmt.getTargetTable();
                if(dropTable == null) {
                        return;
                }
                Table tableModel = modelManager.getTableByName(DlineageUtil.getTableFullName(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.getProcedureByName(
                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                        if (callee == null && procedureDDLMap.containsKey(DlineageUtil.getFunctionNameWithArgNum(functionCall))) {
                                analyzeCustomSqlStmt(procedureDDLMap.get(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                callee = modelManager.getProcedureByName(DlineageUtil
                                                .getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                        }
                        if (callee != null) {
                                String procedureParent = getProcedureParentName(callStmt);
                                if (procedureParent != null) {
                                        Procedure caller = modelManager
                                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                        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 = modelManager
                                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                        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();
                        String functionName = function.toString();
                        Procedure callee = modelManager.getProcedureByName(
                                        DlineageUtil.getIdentifierNormalTableName(functionName));
                        if (callee == null && procedureDDLMap.containsKey(functionName)) {
                                analyzeCustomSqlStmt(procedureDDLMap.get(functionName));
                                callee = modelManager.getProcedureByName(functionName);
                        }
                        if (callee != null) {
                                String procedureParent = getProcedureParentName(callStmt);
                                if (procedureParent != null) {
                                        Procedure caller = modelManager
                                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                        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();
                String functionName = function.toString();
                // DB2 supports procedure overloading by arity, so overloadable procedures
                // register under a "name(argCount)" key (see getFunctionNameWithArgNum).
                // Resolve by name+argCount first to bind the correct overload, then fall
                // back to the plain name for the single-definition / non-overloaded case.
                String nameWithArgNum = functionName;
                if (callStmt.getParameters() != null
                                && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
                        nameWithArgNum = functionName + "(" + callStmt.getParameters().size() + ")";
                }
                Procedure callee = modelManager.getProcedureByName(
                                DlineageUtil.getIdentifierNormalTableName(nameWithArgNum));
                if (callee == null && !nameWithArgNum.equals(functionName)) {
                        callee = modelManager.getProcedureByName(
                                        DlineageUtil.getIdentifierNormalTableName(functionName));
                }
                if (callee == null && procedureDDLMap.containsKey(nameWithArgNum)) {
                        analyzeCustomSqlStmt(procedureDDLMap.get(nameWithArgNum));
                        callee = modelManager.getProcedureByName(nameWithArgNum);
                }
                if (callee == null && procedureDDLMap.containsKey(functionName)) {
                        analyzeCustomSqlStmt(procedureDDLMap.get(functionName));
                        callee = modelManager.getProcedureByName(functionName);
                }
                if (callee != null) {
                        String procedureParent = getProcedureParentName(callStmt);
                        if (procedureParent != null) {
                                Procedure caller = modelManager
                                                .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                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.getProcedureByName(
                                DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                if(callee == null && procedureDDLMap.containsKey(DlineageUtil.getFunctionNameWithArgNum(functionCall))) {
                        analyzeCustomSqlStmt(procedureDDLMap.get(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                        callee = modelManager.getProcedureByName(
                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                }
                if (callee != null) {
                        String procedureParent = getProcedureParentName(stmtStack.peek());
                        if (procedureParent != null) {
                                Procedure caller = modelManager
                                                .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                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;
        }

        private void analyzeOracleBasicStmt(TBasicStmt oracleBasicStmt) {
                if (oracleBasicStmt.getExpr() == null || oracleBasicStmt.getExpr().getFunctionCall() == null) {
                        return;
                }

                TFunctionCall functionCall = oracleBasicStmt.getExpr().getFunctionCall();
                recordDbmsSqlSiteIfParseCall(oracleBasicStmt, functionCall);
                Procedure callee = modelManager.getProcedureByName(
                                DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                if(callee == null && procedureDDLMap.containsKey(DlineageUtil.getFunctionNameWithArgNum(functionCall))) {
                        analyzeCustomSqlStmt(procedureDDLMap.get(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                        callee = modelManager.getProcedureByName(
                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                }
                if (callee != null) {
                        String procedureParent = getProcedureParentName(oracleBasicStmt);
                        if (procedureParent != null) {
                                Procedure caller = modelManager
                                                .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                if (caller != null) {
                                        CallRelationship callRelation = modelFactory.createCallRelation();
                                        callRelation.setCallObject(functionCall);
                                        callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                        callRelation.addSource(new ProcedureRelationshipElement(callee));
                                        if (functionChecker.isOraclePredefinedPackageFunction(functionCall.getFunctionName().toString())
                                                        || (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);
                                        }
                                }
                        }
                } else {
                        Object functionModel = createFunction(functionCall);
                        if (!(functionModel instanceof Function)) {
                                return;
                        }
                        Function function = (Function) functionModel;
                        String procedureParent = getProcedureParentName(oracleBasicStmt);
                        if (procedureParent != null) {
                                Procedure caller = modelManager
                                                .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                if (caller != null) {
                                        CallRelationship callRelation = modelFactory.createCallRelation();
                                        callRelation.setCallObject(functionCall);
                                        callRelation.setTarget(new ProcedureRelationshipElement(caller));
                                        callRelation.addSource(new FunctionRelationshipElement(function));
                                        if (functionChecker.isOraclePredefinedPackageFunction(functionCall.getFunctionName().toString())
                                                        || (isBuiltInFunctionName(functionCall.getFunctionName()) || isKeyword(functionCall.getFunctionName()))) {
                                                callRelation.setBuiltIn(true);
                                        }
                                }
                        }
                }
        }

        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.getProcedureByName(DlineageUtil
                                                        .getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                        if(callee == null && procedureDDLMap.containsKey(DlineageUtil.getFunctionNameWithArgNum(functionCall))) {
                                                analyzeCustomSqlStmt(procedureDDLMap.get(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                                callee = modelManager.getProcedureByName(
                                                                DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                        }
                                        if (callee != null) {
                                                String procedureParent = getProcedureParentName(ifStmt);
                                                if (procedureParent != null) {
                                                        Procedure caller = modelManager
                                                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                                        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 = modelManager
                                                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                                        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.getProcedureByName(DlineageUtil
                                                        .getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                        if(callee == null && procedureDDLMap.containsKey(DlineageUtil.getFunctionNameWithArgNum(functionCall))) {
                                                analyzeCustomSqlStmt(procedureDDLMap.get(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                                callee = modelManager.getProcedureByName(
                                                                DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                        }
                                        if (callee != null) {
                                                String procedureParent = getProcedureParentName(ifStmt);
                                                if (procedureParent != null) {
                                                        Procedure caller = modelManager
                                                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                                        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 = modelManager
                                                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                                        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.getProcedureByName(DlineageUtil
                                                        .getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                        if(callee == null && procedureDDLMap.containsKey(DlineageUtil.getFunctionNameWithArgNum(functionCall))) {
                                                analyzeCustomSqlStmt(procedureDDLMap.get(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                                callee = modelManager.getProcedureByName(
                                                                DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                        }
                                        if (callee != null) {
                                                String procedureParent = getProcedureParentName(elsIfStmt);
                                                if (procedureParent != null) {
                                                        Procedure caller = modelManager
                                                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                                        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 = modelManager
                                                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                                        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 = new TObjectName();
                                sourceName.setString("*");
                                TableColumn sourceTableColumn = modelFactory.createTableColumn(sourceTable, sourceName, false);
                                TObjectName targetName = new TObjectName();
                                targetName.setString("*");
                                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) {
                DynamicHoleEvidence holeEvidence = dynamicHoleEvidence(evaluatedDynamicSqlFor(stmt));
                recordDynamicSqlSite(stmt, kind, DynamicSqlSite.Status.UNRESOLVED, dynamicReasonOf(executeStmt),
                                0, 0, 0, holeEvidence.count, holeEvidence.exact, option.getDynamicSqlTrustMode(),
                                -1, -1, null, null, holeEvidence.fragments, holeEvidence.materializedText);
        }

        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) {
                if (stmt == null || stmt.getStartToken() == null || stmt.getEndToken() == null) {
                        return;
                }
                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));

                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<String> staticTemplateVetoKeys = new HashSet<String>();

        /** 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;
                }
                String[] keys = { DlineageUtil.getTableFullName(rawName),
                                DlineageUtil.getTableFullNameWithDefaultSchema(rawName) };
                for (String key : keys) {
                        if (SQLUtil.isEmpty(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).
         */
        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;
                }
                String analyzedText = analyzedParser.sqltext;
                List<FoldHole> holes;
                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;
                        }
                        if (site.sqlText.equals(analyzedText)) {
                                holes = exactFoldHoles(site, analyzedText);
                        } else {
                                // 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.
                                holes = alignedFoldHoles(site, analyzedText);
                                if (holes == null) {
                                        holes = conservativeFoldHoles(analyzedText);
                                }
                        }
                } else {
                        holes = conservativeFoldHoles(analyzedText);
                }
                if (holes.isEmpty()) {
                        return;
                }
                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);
                        }
                }
                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.getTableFullName(intoTarget.toString()));
                        markDynamicTemplateEndpoint(before, intoTarget, model, analyzedText, holes);
                }
        }

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

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

                @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.getTableFullName(tableName.toString()))
                                || staticTemplateVetoKeys.contains(
                                                DlineageUtil.getTableFullNameWithDefaultSchema(tableName.toString()))) {
                        return;
                }
                model.markDynamicTemplate(parts.toString(), identityTemplated);
                anyDynamicTemplateMarked = true;
        }

        /** 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 = sqlparser.parse();
                                        } 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;
                        }
                }
                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 (sqlparser.parse() != 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 && "*".equals(inputColumn.getName())) {
                                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 = sqlparser.parse();
                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());
                        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 (sqlparser.parse() == 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 = sqlparser.parse();
                        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);
                        }
                }
        }
        
        private void analyzeLoadDataStmt(TLoadDataStmt stmt) {
                
        }

        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.getStarLinkColumnNames().size() > 0) {
                                                        for (int k = 0; k < resultColumn.getStarLinkColumnNames().size(); 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.getTableFullName(stmt.getTableName().toString()));
                                if (intoTable == null) {
                                        intoTable = modelFactory.createTableByName(stmt.getTableName(), false);
                                        TObjectName starColumn = new TObjectName();
                                        starColumn.setString("*");
                                        TableColumn column = modelFactory.createTableColumn(intoTable, starColumn, false);
                                        if (column != null) {
                                                column.setExpandStar(false);
                                                column.setPseduo(true);
                                        }
                                }
                                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) {
                                        String stageFullName = DlineageUtil.getTableFullName(stageName.toString());
                                        Table stage = modelManager.getTableByName(stageFullName);
                                        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 && !intoTable.getColumns().isEmpty() && !stage.getColumns().isEmpty()) {
                                                        for (int i = 0; i < intoTable.getColumns().size(); i++) {
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.addSource(new TableColumnRelationshipElement(stage.getColumns().get(0)));
                                                                relation.setTarget(new TableColumnRelationshipElement(intoTable.getColumns().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 && !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);
                                                        }
                                                }
                                        }
                                }
                        }
                        else if (stmt.getSubQuery() != null) {
                                analyzeSelectStmt(stmt.getSubQuery());
                                
                                Table intoTable = modelManager
                                                .getTableByName(DlineageUtil.getTableFullName(stmt.getTableName().toString()));
                                if (intoTable == null) {
                                        intoTable = modelFactory.createTableByName(stmt.getTableName(), false);
                                        TObjectName starColumn = new TObjectName();
                                        starColumn.setString("*");
                                        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.getTableFullName(stmt.getTableName().toString()));
                        if (intoTable == null) {
                                intoTable = modelFactory.createTableByName(stmt.getTableName(), false);
                                if (stmt.getColumnList() == null || stmt.getColumnList().size() == 0) {
                                        TObjectName starColumn = new TObjectName();
                                        starColumn.setString("*");
                                        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);
                                                }
                                        }
                                }
                        }
                }
        }

        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.getTableFullName(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 = new TObjectName();
                                synonymStarColumn.setString("*");
                                TableColumn synonymTableStarColumn = modelFactory.createTableColumn(synonymTableModel,
                                                synonymStarColumn, true);
                                TObjectName sourceStarColumn = new TObjectName();
                                sourceStarColumn.setString("*");
                                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.
         */
        private void materializeSqlEnvSynonyms() {
                if (sqlenv == null) {
                        return;
                }
                List<Table> snapshot = new ArrayList<Table>(modelManager.getTablesByName());

                Map<String, TSQLSynonyms> synonymCache = new HashMap<>();
                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;
                                                        String qualifiedName = synonym.getQualifiedName();
                                                        String normalizedName = DlineageUtil.getIdentifierNormalTableName(qualifiedName);
                                                        synonymCache.put(normalizedName, synonym);
                                                }
                                        }
                                }
                        }
                }

                for (Table synonymTableModel : snapshot) {
                        if (synonymTableModel == null) {
                                continue;
                        }
                        if (SubType.synonym.equals(synonymTableModel.getSubType())) {
                                continue;
                        }
                        String qualifiedName = ModelFactory.getQualifiedTableName(synonymTableModel);
                        String normalizedName = DlineageUtil.getIdentifierNormalTableName(qualifiedName);
                        TSQLSynonyms synonym = synonymCache.get(normalizedName);
                        if (synonym == null) {
                                continue;
                        }

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

                        synonymTableModel.setSubType(SubType.synonym);

                        TObjectName baseObjectName = new TObjectName();
                        baseObjectName.setString(baseSqlTableQualifiedName);
                        Table baseTableModel = modelFactory.createTableByName(baseObjectName);
                        if (baseTableModel == null || baseTableModel == synonymTableModel) {
                                continue;
                        }

                        for (TableColumn synonymColumn : new ArrayList<TableColumn>(synonymTableModel.getColumns())) {
                                String colName = synonymColumn.getName();
                                if (SQLUtil.isEmpty(colName) || "*".equals(colName)) {
                                        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);
                                        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 = new TObjectName();
                oldStarColumn.setString("*");
                TableColumn oldTableStarColumn = modelFactory.createTableColumn(oldNameTableModel, oldStarColumn, true);
                
                Table newNameTableModel = modelFactory.createTableByName(newTableName);
                TObjectName newStarColumn = new TObjectName();
                newStarColumn.setString("*");
                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);
                }
        }
        
        private void analyzeAlterTableStmt(TAlterTableStatement stmt) {
                TTable oldNameTable = stmt.getTargetTable();
                if (oldNameTable == null) {
                        return;
                }

                Table oldNameTableModel = modelFactory.createTable(oldNameTable);
                TObjectName oldStarColumn = new TObjectName();
                oldStarColumn.setString("*");
                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 = new TObjectName();
                                                newStarColumn.setString("*");
                                                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 = new TObjectName();
                                        newStarColumn.setString("*");
                                        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 = new TObjectName();
                                                newStarColumn.setString("*");
                                                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 = new TObjectName();
                                        newStarColumn.setString("*");
                                        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 = new TObjectName();
                                                newStarColumn.setString("*");
                                                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 = new TObjectName();
                                        newStarColumn.setString("*");
                                        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.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 = new TObjectName();
                                        fileUri.setString("*");
                                        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) {
                                                        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);
                                                        }
                                                }
                                        }
                                }
                        }
                        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.getTableFullName(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.getTableFullName(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.getTableFullName(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) {
                        if (this.modelManager.getOraclePackageByName(
                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithArgs(stmt))) == 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.getOraclePackageByName(
                                                DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithArgs(stmt))));
                        }
                        
                        try {
                                if (stmt.getDeclareStatements() != null) {
                                        for (int i = 0; i < stmt.getDeclareStatements().size(); ++i) {
                                                analyzeCustomSqlStmt(stmt.getDeclareStatements().get(i));
                                        }
                                }
                        } finally {
                                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;
                }
                
                ModelBindingManager.setGlobalProcedure(stmt);

                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().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) {
                                        // Non-package routines: body references register their
                                        // variables under the getTableFullName-composed scope (the
                                        // parent-statement branch of getProcedureParentName), which
                                        // under a USE database context differs BOTH from the raw
                                        // declared name and from the display name — leaving nested
                                        // EXEC argument binding without a matching key. Capture the
                                        // body-side composition here, under the declaration's own
                                        // ambient context.
                                        procedure.setVariableScopeKey(DlineageUtil.getTableFullName(
                                                        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. Mode-gated — LEGACY never
                                        // pushes, so the identity pool path stays cold there.
                                        if (option.isIdentityFirstVariablePools()
                                                        && procedure.getIdentityScopeKey() != null) {
                                                modelFactory.pushIdentityScope(procedure.getIdentityScopeKey());
                                                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 = new TObjectName();
                                                                variableProperties.setString("*");
                                                                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.getProcedureByName(DlineageUtil
                                                                        .getTableFullName(expression.getFunctionCall().getFunctionName().toString()));
                                                        if (targetProcedure == null) {
                                                                targetProcedure = modelManager
                                                                                .getProcedureByName(DlineageUtil.getTableFullName(procedure.getSchema() + "."
                                                                                                + expression.getFunctionCall().getFunctionName().toString()));
                                                        }
                                                        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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent), 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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                                        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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent), 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 (DlineageUtil.compareColumnIdentifier(getColumnName(resultColumn.getName()),
                                                                                        DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                                        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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                                        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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedure.getName()),
                                                        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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                                returnResult);
                        }
                } finally {
                        if (pushedIdentityScope) {
                                modelFactory.popIdentityScope();
                        }
                        ModelBindingManager.removeGlobalProcedure();
                }

        }

        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) {
                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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                                returnResult);
                        }
                }
        }

        private void analyzeReturnStmt(TReturnStmt 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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                        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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                                        returnResult);
                                        return;
                                }
                        }
                        
                        ResultColumn resultColumn = null;
                        if (returnExpression.getExpressionType() == EExpressionType.simple_object_name_t) {
                                TObjectName columnName = new TObjectName();
                                columnName.setString("*");
                                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).getName().indexOf("*") == -1) {
                                                star = false;
                                        }
                                        if (column instanceof ResultColumn && ((ResultColumn) column).getName().indexOf("*") == -1) {
                                                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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                                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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                        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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                                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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent),
                                                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 ("*".equals(existing.getName())) {
                                        return existing;
                                }
                        }
                }
                TableColumn starColumn = modelFactory.createTableColumn(table, starObjectName(), true);
                starColumn.setShowStar(false);
                starColumn.setExpandStar(true);
                return starColumn;
        }

        private TObjectName starObjectName() {
                TObjectName starColumn = new TObjectName();
                starColumn.setString("*");
                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.createVariable(columnObject);
                                        cursorVariable.setSubType(SubType.record);
                                        if (cursorVariable.isDetermined()) {
                                                if (stmt.getCursorName() != null) {
                                                        String procedureName = DlineageUtil.getProcedureParentName(stmt);
                                                        String variableString = stmt.getCursorName().toString();
                                                        if (variableString.startsWith(":")) {
                                                                variableString = variableString.substring(variableString.indexOf(":") + 1);
                                                        }
                                                        if (!SQLUtil.isEmpty(procedureName)) {
                                                                variableString = procedureName + "."
                                                                                + SQLUtil.getIdentifierNormalTableName(variableString);
                                                        }
                                                        Table cursor = modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
                                                        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 && !"*".equals(field.getName())) {
                                                                                hasRealField = true;
                                                                                break;
                                                                        }
                                                                }
                                                                int fieldOrdinal = 0;
                                                                for (int k = 0; k < recordFields.size(); k++) {
                                                                        TableColumn variableProperty = recordFields.get(k);
                                                                        if ("*".equals(variableProperty.getName()) && 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 = new TObjectName();
                                                                starColumn.setString("*");
                                                                variableProperty = modelFactory.createTableColumn(cursorVariable, starColumn, true);
                                                        } else {
                                                                variableProperty = cursorVariable.getColumns().get(0);
                                                        }
                                                } else {
                                                        variableProperty = modelFactory.createTableColumn(cursorVariable, columnObject, true);
                                                }

                                                if (stmt.getCursorName() != null) {
                                                        String procedureName = DlineageUtil.getProcedureParentName(stmt);
                                                        String variableString = stmt.getCursorName().toString();
                                                        if (variableString.startsWith(":")) {
                                                                variableString = variableString.substring(variableString.indexOf(":") + 1);
                                                        }
                                                        if (!SQLUtil.isEmpty(procedureName)) {
                                                                variableString = procedureName + "."
                                                                                + SQLUtil.getIdentifierNormalTableName(variableString);
                                                        }
                                                        Table cursor = modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
                                                        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.createVariable(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 = new TObjectName();
                                                starColumn.setString("*");
                                                variableProperty = modelFactory.createTableColumn(cursorVariable, starColumn, true);
                                        } else {
                                                variableProperty = cursorVariable.getColumns().get(0);
                                        }
                                } else {
                                        variableProperty = modelFactory.createTableColumn(cursorVariable, columnObject, true);
                                }

                                if (stmt.getCursorName() != null) {
                                        String procedureName = DlineageUtil.getProcedureParentName(stmt);
                                        String variableString = stmt.getCursorName().toString();
                                        if (variableString.startsWith(":")) {
                                                variableString = variableString.substring(variableString.indexOf(":") + 1);
                                        }
                                        if (!SQLUtil.isEmpty(procedureName)) {
                                                variableString = procedureName + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                                        }
                                        Table cursor = modelManager
                                                        .getTableByName(DlineageUtil.getTableFullName(variableString));
                                        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 = new TObjectName();
                                starColumn.setString("*");
                                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 = new TObjectName();
                        starColumn.setString("*");
                        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));
                        }
                }
        }

        /**
         * Resolve a declared name visible from the CURRENT scope (#695): a TYPE
         * declared at package level is visible from every nested procedure, but
         * variable models are keyed under their declaring scope only, so 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 → package → global); never create.
         */
        private Variable resolveVariableInScope(String name) {
                if (SQLUtil.isEmpty(name)) {
                        return null;
                }
                Variable direct = modelFactory.createVariable(name, false);
                if (direct != null) {
                        return direct;
                }
                String normalized = SQLUtil.getIdentifierNormalTableName(name);
                // Lexical chain first (codex-696 F1): a declaration in an ENCLOSING
                // procedure shadows the package's. getProcedureParentName() of the
                // current statement omits intermediate nesting levels, so probe each
                // enclosing stored-procedure statement on the stack, innermost first.
                for (int depth = stmtStack.size() - 1; depth >= 0; depth--) {
                        String enclosingScope = DlineageUtil.getProcedureParentName(stmtStack.get(depth));
                        if (SQLUtil.isEmpty(enclosingScope)) {
                                continue;
                        }
                        Object model = modelManager.getTableByName(DlineageUtil.getTableFullName(
                                        DlineageUtil.getTableFullName(enclosingScope) + "." + normalized));
                        if (model instanceof Variable) {
                                return (Variable) model;
                        }
                }
                String scope = stmtStack.isEmpty() ? null : DlineageUtil.getProcedureParentName(stmtStack.peek());
                while (!SQLUtil.isEmpty(scope)) {
                        int cut = scope.lastIndexOf('.');
                        scope = cut == -1 ? null : scope.substring(0, cut);
                        List<String> keys = new ArrayList<String>();
                        if (SQLUtil.isEmpty(scope)) {
                                keys.add(normalized);
                        } else {
                                keys.add(DlineageUtil.getTableFullName(scope) + "." + normalized);
                                // A declaration at the top level of a package BODY is scoped
                                // "<pkg>.<pkg>" (the body's own block), so a sibling procedure
                                // walking up to "<pkg>" must probe that block scope too.
                                String tail = scope.indexOf('.') == -1 ? scope : scope.substring(scope.lastIndexOf('.') + 1);
                                keys.add(DlineageUtil.getTableFullName(scope) + "." + tail + "." + normalized);
                        }
                        for (String key : keys) {
                                Object model = modelManager.getTableByName(DlineageUtil.getTableFullName(key));
                                if (model instanceof Variable) {
                                        return (Variable) model;
                                }
                        }
                        if (cut == -1) {
                                break;
                        }
                }
                return 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 && !"*".equals(existing.getName())) {
                                        hadRealFields = true;
                                        break;
                                }
                        }
                }
                for (TableColumn typeField : typeModel.getColumns()) {
                        if (typeField.getName() == null || "*".equals(typeField.getName())) {
                                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 ("*".equals(existing.getName())) {
                                        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 (!"*".equals(column.getName())) {
                                        return recovered;
                                }
                        }
                }
                return null;
        }

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

                        Table variableTable = modelFactory.createTableByName(typeName.getDataTypeName(), false);
                        if(!variableTable.isCreateTable()) {
                                TObjectName starColumn1 = new TObjectName();
                                starColumn1.setString("*");
                                TableColumn variableTableStarColumn = modelFactory.createTableColumn(variableTable, starColumn1, true);
                                variableTableStarColumn.setShowStar(false);
                                variableTableStarColumn.setExpandStar(true);

                                TObjectName starColumn = new TObjectName();
                                starColumn.setString("*");
                                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 = new TObjectName();
                                                objectName.setString("*");
                                                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 = new TObjectName();
                                        objectName.setString("*");
                                        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().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.createVariable(splits.get(splits.size() - 2));
                        } else {
                                tableModel = modelFactory.createVariable(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.createVariable(splits.get(splits.size() - 2));
                        } else {
                                tableModel = modelFactory.createVariable(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.createVariable(splits.get(splits.size() - 2));
                        } else {
                                tableModel = modelFactory.createVariable(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;
                }
                TCustomSqlStatement proc = null;
                for (int i = stmtStack.size() - 1; i >= 0; i--) {
                        if (stmtStack.get(i) instanceof TStoredProcedureSqlStatement) {
                                proc = stmtStack.get(i);
                                break;
                        }
                }
                if (proc == null) {
                        return null;
                }
                List<Map<TCustomSqlStatement, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>> variants = dynamicEvalCache
                                .get(proc);
                if (variants == null) {
                        variants = new ArrayList<Map<TCustomSqlStatement, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>>();
                        try {
                                variants.addAll(gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                                .materializeSiteVariants(proc, option.getVendor(), null, null));
                                // 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.
                                List<Map<String, gudusoft.gsqlparser.dlineage.dynamicsql.SqlValue>> sameFileBindings = gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                                .discoverCallSiteBindings(proc, 4);
                                for (Map<String, gudusoft.gsqlparser.dlineage.dynamicsql.SqlValue> bindings : sameFileBindings) {
                                        variants.addAll(gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                                        .materializeSiteVariants(proc, option.getVendor(), bindings, null));
                                }
                                // 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 && sameFileBindings.size() < 4) {
                                        for (Map<String, gudusoft.gsqlparser.dlineage.dynamicsql.SqlValue> bindings : gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                                        .discoverCrossFileCallSiteBindings(proc, routineCatalog,
                                                                        4 - sameFileBindings.size())) {
                                                variants.addAll(gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver
                                                                .materializeSiteVariants(proc, option.getVendor(), bindings, null));
                                        }
                                }
                        } catch (RuntimeException ex) {
                                // evaluation is best-effort; fall through with whatever variants exist
                        }
                        dynamicEvalCache.put(proc, variants);
                }
                // Prefer the first fully-concrete materialization; otherwise the first
                // usable partial text; otherwise the no-bindings entry (carries the reason).
                gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite best = null;
                for (Map<TCustomSqlStatement, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite> variant : variants) {
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite candidate = variant.get(execStmt);
                        if (candidate == null) {
                                continue;
                        }
                        if (candidate.sqlText != null && !candidate.partial) {
                                return candidate;
                        }
                        if (best == null || (best.sqlText == null && candidate.sqlText != null)) {
                                best = candidate;
                        }
                }
                return best;
        }

        /** All distinct usable materializations for one EXEC, in stable variant order. */
        private List<gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite> evaluatedDynamicSqlVariantsFor(
                        TCustomSqlStatement execStmt, boolean concreteOnly) {
                // Builds and caches the variant list on first use.
                evaluatedDynamicSqlFor(execStmt);
                TCustomSqlStatement proc = null;
                for (int i = stmtStack.size() - 1; i >= 0; i--) {
                        if (stmtStack.get(i) instanceof TStoredProcedureSqlStatement) {
                                proc = stmtStack.get(i);
                                break;
                        }
                }
                List<gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite> result =
                                new ArrayList<gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>();
                if (proc == null) {
                        return result;
                }
                List<Map<TCustomSqlStatement, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite>> variants =
                                dynamicEvalCache.get(proc);
                Set<String> seen = new LinkedHashSet<String>();
                for (Map<TCustomSqlStatement, gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite> variant : variants) {
                        gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlLineageResolver.MaterializedSite candidate =
                                        variant.get(execStmt);
                        if (candidate == null || candidate.sqlText == null
                                        || (concreteOnly && candidate.partial)
                                        || isWholeTextHole(candidate)) {
                                continue;
                        }
                        String key = candidate.partial + "\u0000" + candidate.sqlText;
                        if (seen.add(key)) {
                                result.add(candidate);
                        }
                }
                return result;
        }

        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 = sqlparser.parse();
                if (result == 0 && sqlparser.sqlstatements != null) {
                        foldStatementsAnalyzed = true;
                        dynamicFoldDepth++;
                        try {
                                for (int i = 0; i < sqlparser.sqlstatements.size(); i++) {
                                        analyzeCustomSqlStmt(sqlparser.sqlstatements.get(i));
                                }
                        } finally {
                                dynamicFoldDepth--;
                        }
                }
                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);
                        return true;
                }
                boolean usable = dynCounts[2] == 0
                                && (dynCounts[0] > 0 || (dynCounts[1] == 0 && dynCounts[3] > 0));
                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);
                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());
                                }
                        }
                }
                String scope = null;
                if (trigger.getStatements() != null && trigger.getStatements().size() > 0) {
                        scope = DlineageUtil.getProcedureParentName(trigger.getStatements().get(0));
                }
                for (String correlationName : correlationNames) {
                        modelManager.bindTableByName(DlineageUtil.getTableFullName(":" + correlationName), sourceTable);
                        if (!SQLUtil.isEmpty(scope)) {
                                modelManager.bindTableByName(DlineageUtil.getTableFullName(
                                                scope + "." + SQLUtil.getIdentifierNormalTableName(correlationName)), 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.createVariable(splits.get(splits.size() - 2));
                                } else {
                                        tableModel = modelFactory.createVariable(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) {
                                        Table tableModel = modelManager
                                                        .getTableByName(DlineageUtil.getTableFullName(splits.get(splits.size() - 2)));
                                        if (tableModel == null) {
                                                String procedureName = DlineageUtil.getProcedureParentName(stmt);
                                                String variableString = splits.get(splits.size() - 2).toString();
                                                if (variableString.startsWith(":")) {
                                                        variableString = variableString.substring(variableString.indexOf(":") + 1);
                                                }
                                                if (!SQLUtil.isEmpty(procedureName)) {
                                                        variableString = procedureName + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                                                }
                                                tableModel = modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
                                        }
                                        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 = new TObjectName();
                        starColumn.setString("*");
                        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 = new TObjectName();
                                starColumn.setString("*");
                                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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent), 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 = new TObjectName();
                                        variableProperties.setString("*");
                                        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.bindTableFunction(DlineageUtil.getIdentifierNormalTableName(procedureParent), 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 = new TObjectName();
                                                variableProperties.setString("*");
                                                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 = new TObjectName();
                                        starColumn.setString("*");
                                        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.getIdentifierNormalTableName(variableName.toString())
                                        .equals(DlineageUtil.getIdentifierNormalTableName(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;
        }

        private void analyzeCreateTableStmt(TCreateTableSqlStatement stmt) {
                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 && stmt.getSubQuery().getResultColumnList().toString().indexOf("*") == -1));
                        // 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;
                                                }
                                                for (int i = 0; i < tableColumnSize && j < resultSetSize; i++) {
                                                        ResultColumn resultColumn = resultSetModel.getColumns().get(j);
                                                        if (i < stmtColumnSize) {
                                                                TObjectName alias = stmt.getColumnList().getColumn(i).getColumnName();
                                                                
                                                                if (!resultSetModel.getColumns().get(j).getName().contains("*")) {
                                                                        j++;
                                                                } else {
                                                                        if (resultSetSize - j == stmt.getColumnList().size() - i) {
                                                                                j++;
                                                                        }
                                                                }

                                                                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(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.setProcess(process);
                                                                        }
                                                                } 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.getStarLinkColumns().isEmpty()) {
                                                                                viewColumn.bindStarLinkColumns(column.getStarLinkColumns());
                                                                        }
                                                                        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 {
                                        for (int i = 0; i < stmt.getColumnList().size(); i++) {
                                                TColumnDefinition column = stmt.getColumnList().getColumn(i);
                                                if (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 (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 (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.getTableFullName(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.getName().endsWith("*")) {
                                                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.getName().endsWith("*") && 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 || columnObj.toString().endsWith("*")) && !resultColumn.getName().endsWith("*")) {
                                                                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) {
                                                                        if (tableModel.getColumns().isEmpty()) {
                                                                                logger.info("Add table " + tableModel.getName() + " column " + columnObj.toString() + " failed");
                                                                        }
                                                                        else if (resultColumn.getName().endsWith("*")) {
                                                                                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.getName().endsWith("*")
                                                                                                        && resultColumn.getName().endsWith("*")) {
                                                                                                tableModel.setStarStmt("create_table");
                                                                                        }
                                                                                        Process process = modelFactory.createProcess(stmt);
                                                                                        relation.setProcess(process);
                                                                                }
                                                                        }
                                                                        continue;
                                                                }
                                                                if (!tableColumn.getName().endsWith("*") && tableModel.isDetermined()) {
                                                                        appendTableColumnToSQLEnv(tableModel, tableColumn);
                                                                }

                                                                Object model = modelManager
                                                                                .getModel(resultColumn.getColumnObject());
                                                                if (model instanceof ResultColumn) {
                                                                        ResultColumn column = (ResultColumn) model;
                                                                        if (tableColumn.getName().endsWith("*") && column != null
                                                                                        && !column.getStarLinkColumns().isEmpty()) {
                                                                                tableColumn.bindStarLinkColumns(column.getStarLinkColumns());
                                                                        }

                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.create_table);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                        if (tableColumn.getName().endsWith("*") && resultColumn.getName().endsWith("*")) {
                                                                                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 (columnObj.toString().endsWith("*")) {
                                                                                for (String key : resultColumns.keySet()) {
                                                                                        tableColumn = modelFactory.createInsertTableColumn(tableModel, resultColumns.get(key).getName());
                                                                                        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.getName());
                                                                                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.getName().endsWith("*")) {
                                                                        for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                                                tableColumn = tableModel.getColumns().get(j);
                                                                                ResultColumn column = (ResultColumn) modelManager
                                                                                                .getModel(resultColumn.getColumnObject());
                                                                                if (tableColumn.getName().endsWith("*") && column != null
                                                                                                && !column.getStarLinkColumns().isEmpty()) {
                                                                                        tableColumn.bindStarLinkColumns(column.getStarLinkColumns());
                                                                                }

                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.create_table);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                if (tableColumn.getName().endsWith("*")
                                                                                                && resultColumn.getName().endsWith("*")) {
                                                                                        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.getName());
                                                                                        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.getName().endsWith("*") && column != null
                                                                                                && !column.getStarLinkColumns().isEmpty()) {
                                                                                        tableColumn.bindStarLinkColumns(column.getStarLinkColumns());
                                                                                }

                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.create_table);
                                                                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(resultColumn));
                                                                                if (tableColumn.getName().endsWith("*")
                                                                                                && resultColumn.getName().endsWith("*")) {
                                                                                        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.getStarLinkColumns().isEmpty()) {
                                                                tableColumn.bindStarLinkColumns(column.getStarLinkColumns());
                                                        }

                                                        if (!tableColumn.getName().endsWith("*") && 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) {
                                                TableColumn tableColumn = null;
                                                if (!hasDefinition) {
                                                        tableColumn = modelFactory.createTableColumn(tableModel,
                                                                        (TObjectName) resultColumn.getColumnObject(), !hasDefinition);
                                                } else {
                                                        tableColumn = tableModel.getColumns().get(i);
                                                }

                                                if (!tableColumn.getName().endsWith("*") && 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.getName().endsWith("*") && 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 (!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.getStarLinkColumns().isEmpty()) {
                                                                tableColumn.bindStarLinkColumns(column.getStarLinkColumns());
                                                        }

                                                        if (!tableColumn.getName().endsWith("*") && 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 {
                                                        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.getName().endsWith("*") && 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.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) {
                                tableModel
                                                .setLocation(DlineageUtil.getTableFullName(stmt.getStageLocation().getStageName().toString()));
                                Process process = modelFactory.createProcess(stmt);
                                process.setType("Create External Table");
                                tableModel.addProcess(process);
                                Table stage = modelManager.getTableByName(DlineageUtil.getTableFullName(tableModel.getLocation()));
                                if (stage == null) {
                                        stage = modelManager.getTableByName(
                                                        DlineageUtil.getTableFullName(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 = new TObjectName();
                                                starColumn.setString("*");
                                                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 (stmt.getTableOptions() != null && !stmt.getTableOptions().isEmpty()) {
                                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 = new TObjectName();
                                                starColumn.setString("*");
                                                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) {
                                                                TObjectName fileUri = new TObjectName();
                                                                fileUri.setString(tableModel.getColumns().get(j).getColumnObject().toString());
                                                                TableColumn fileUriColumn = modelFactory.createFileUri(uriFile, fileUri);
                                                                relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                                        } else {
                                                                TObjectName fileUri = new TObjectName();
                                                                fileUri.setString("*");
                                                                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 = new TObjectName();
                                                        fileUri.setString("*");
                                                        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);
                                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) {
                                                TObjectName fileUri = new TObjectName();
                                                fileUri.setString(tableModel.getColumns().get(j).getColumnObject().toString());
                                                TableColumn fileUriColumn = modelFactory.createFileUri(uriFile, fileUri);
                                                relation.addSource(new TableColumnRelationshipElement(fileUriColumn));
                                        } else {
                                                TObjectName fileUri = new TObjectName();
                                                fileUri.setString("*");
                                                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.getTableFullName(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.getTableFullName(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;
        }

        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里
                if (sqlenv != null && tableColumn!=null) {
                        TSQLSchema schema = sqlenv.getSQLSchema(DlineageUtil.getTableSchema(tableModel), true);
                        if (schema != null) {
                                TSQLTable tempTable = schema.createTable(DlineageUtil.getSimpleTableName(tableModel.getName()));
                                if (tableColumn.hasStarLinkColumn()) {
                                        for (String column : tableColumn.getStarLinkColumnNames()) {
                                                tempTable.addColumn(DlineageUtil.getColumnNameOnly(column));
                                        }
                                } else {
                                        tempTable.addColumn(DlineageUtil.getColumnNameOnly(tableColumn.getName()));
                                }
                        }
                }
        }

        private void appendTableColumnToSQLEnv(Table tableModel, TObjectName tableColumn) {
                if (sqlenv != null) {
                        TSQLSchema schema = sqlenv.getSQLSchema(DlineageUtil.getTableSchema(tableModel), true);
                        if (schema != null) {
                                TSQLTable tempTable = schema.createTable(DlineageUtil.getSimpleTableName(tableModel.getName()));
                                tempTable.addColumn(DlineageUtil.getColumnNameOnly(tableColumn.getColumnNameOnly()));
                        }
                }
        }

        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.getTableFullName(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) {
                                List<Table> tables = modelManager.getTablesByName();
                                if (tables != null) {
                                        for (Table referTable : tables) {
                                                if (referTable.getLocation() != null && referTable.getLocation()
                                                                .equals(DlineageUtil.getIdentifierNormalTableName(tableModel.getName()))) {
                                                        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);
                }
        }

        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();
                                                TExpression target = assignment == null ? null : assignment.getLeftOperand();
                                                if (target == null || target.getExpressionType() != EExpressionType.simple_object_name_t) {
                                                        addCteWriteIntentWarning(intent,
                                                                        "an UPDATE assignment target cannot be mapped to a CTE projection");
                                                        continue;
                                                }
                                                addCteWriteIntentColumn(intent, target.getObjectOperand());
                                        }
                                }
                        }
                        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;
                        }
                        TExpression target = assignment.getLeftOperand();
                        if (target == null) {
                                addCteWriteIntentWarning(intent,
                                                "an UPDATE assignment target cannot be mapped to a CTE projection");
                                continue;
                        }
                        if (target.getExpressionType() == EExpressionType.simple_object_name_t) {
                                addCteWriteIntentColumn(intent, target.getObjectOperand());
                        } else if (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");
                        }
                }
                if (intent.columns.isEmpty() && intent.unsupportedReason == null) {
                        intent.unsupportedReason = "the UPDATE has no modified columns from which to resolve a base table";
                }
                return intent;
        }

        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 (SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn,
                                        columnName, column.getName())) {
                                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 "*".equals(projection.getExpr().getObjectOperand().getColumnNameOnly());
        }

        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 (Set<TObjectName> starLinkColumns : sourceColumn.getStarLinkColumns().values()) {
                                        for (TObjectName starLinkColumn : starLinkColumns) {
                                                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) {
                if (!cteSelectRelationKeys.add(new CteSelectRelationKey(targetColumn, sourceColumn))) {
                        return;
                }
                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                relation.setEffectType(EffectType.select);
                relation.setTarget(new ResultColumnRelationshipElement(targetColumn));
                relation.addSource(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;
                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()));
                                        }
                                }
                        } 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 (Set<TObjectName> starLinkColumns : sourceColumn.getStarLinkColumns().values()) {
                                                                        for (TObjectName starLinkColumn : starLinkColumns) {
                                                                                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()));
                                                }
                                        }
                                }
                        } else {
                                if (stmt.getUsingTable().getAliasClause() != null && stmt.getUsingTable().getAliasClause().getColumns() != 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 {
                                        modelFactory.createTable(stmt.getUsingTable());
                                }
                        }
                

                        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) {
                                                analyzeFilterCondition(null, clause.getCondition(), 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);

                                                for (int j = 0; j < columns.size(); j++) {
                                                        TResultColumn resultColumn = columns.getResultColumn(j);
                                                        if (resultColumn.getExpr().getLeftOperand()
                                                                        .getExpressionType() == EExpressionType.simple_object_name_t) {
                                                                TObjectName columnObject = resultColumn.getExpr().getLeftOperand().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;
                                                                }

                                                                ResultColumn updateColumn = modelFactory.createMergeResultColumn(resultSet,
                                                                                columnObject);

                                                                TExpression valueExpression = resultColumn.getExpr().getRightOperand();
                                                                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(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);

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

                                                        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().indexOf("row") != -1) {
                                                                        if (stmt.getUsingTable().getSubquery() != null && tableModel instanceof Table) {
                                                                                ResultSet sourceResultSet = modelFactory.createQueryTable(stmt.getUsingTable());
                                                                                TObjectName targetStarColumn = new TObjectName();
                                                                                targetStarColumn.setString("*");
                                                                                TableColumn targetTableColumn = modelFactory.createTableColumn((Table)tableModel,
                                                                                                targetStarColumn, true);
                                                                                if (sourceResultSet.getColumns() == null
                                                                                                || sourceResultSet.getColumns().isEmpty()) {
                                                                                        TObjectName sourceStarColumn = new TObjectName();
                                                                                        sourceStarColumn.setString("*");
                                                                                        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 = new TObjectName();
                                                                                sourceStarColumn.setString("*");
                                                                                TableColumn sourceTableColumn = modelFactory.createTableColumn(sourceTable,
                                                                                                sourceStarColumn, true);
                                                                                TObjectName targetStarColumn = new TObjectName();
                                                                                targetStarColumn.setString("*");
                                                                                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);

                                                        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) {
                                analyzeFilterCondition(null, stmt.getCondition(), null, JoinClauseType.on, EffectType.merge);
                        }
                }
        }

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

        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 (!getColumnName(targetNames.get(0))
                                                .equals(getColumnName(names.get(0)))) {
                                        continue;
                                }
                        }
                        if (getColumnName(column.getColumnObject().toString()).equals(getColumnName(columnName))) {
                                return column;
                        }
                }
                return null;
        }
        
        private TableColumn matchColumn(List<TableColumn> tableColumns, TObjectName columnName) {
                if (tableColumns == null) {
                        return 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))
                                return column;
                }
                return null;
        }

        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.getName().endsWith("*")) {
                                if ("*".equals(column.getColumnObject().toString())) {
                                        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.getName().endsWith("*")) {
                                if ("*".equals(column.getColumnObject().toString())) {
                                        return column;
                                } else {
                                        TObjectName columnObjectName = getObjectName(column);
                                        if (columnObjectName.getTableString() != null
                                                        && columnObjectName.getTableString().equals(columnName.getTableString())) {
                                                return column;
                                        }
                                }
                        }
                }
                return null;
        }

        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>>();
                Map<String, List<TableColumn>> tableColumnMap = new LinkedHashMap<String, List<TableColumn>>();
                List<Table> inserTables = new ArrayList<Table>();
                List<TExpression> expressions = new ArrayList<TExpression>();
                boolean hasInsertColumns = false;
                
                EffectType effectType = EffectType.insert;
                if(stmt.getInsertToken()!=null && stmt.getInsertToken().toString().toLowerCase().startsWith("replace")) {
                        effectType = EffectType.replace;
                }
                
                if (stmt.getInsertConditions() != null && stmt.getInsertConditions().size() > 0) {
                        for (int i = 0; i < stmt.getInsertConditions().size(); i++) {
                                TInsertCondition condition = stmt.getInsertConditions().getElement(i);
                                if (condition.getCondition() != null) {
                                        expressions.add(condition.getCondition());
                                }
                                for (int j = 0; j < condition.getInsertIntoValues().size(); j++) {
                                        TInsertIntoValue value = condition.getInsertIntoValues().getElement(j);
                                        TTable table = value.getTable();
                                        Table tableModel = modelFactory.createTable(table);

                                        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(DlineageUtil.getIdentifierNormalTableName(table.getFullName())) == null
                                                        && !tableColumns.isEmpty()) {
                                                tableColumnMap.put(DlineageUtil.getIdentifierNormalTableName(tableModel.getFullName()),
                                                                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);

                                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(DlineageUtil.getIdentifierNormalTableName(tableModel.getFullName())) == null && !tableColumns.isEmpty()) {
                                        tableColumnMap.put(DlineageUtil.getIdentifierNormalTableName(tableModel.getFullName()), 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(DlineageUtil.getIdentifierNormalTableName(tableModel.getFullName())) == null && !tableColumns.isEmpty()) {
                                tableColumnMap.put(DlineageUtil.getIdentifierNormalTableName(tableModel.getFullName()), 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();
                                        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(DlineageUtil.getIdentifierNormalTableName(tableModel.getFullName())) == null && !tableColumns.isEmpty()) {
                                tableColumnMap.put(DlineageUtil.getIdentifierNormalTableName(tableModel.getFullName()), 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(DlineageUtil.getIdentifierNormalTableName(table.getFullName())) == null) {
                                if (tableModel.getColumns() != null && !tableModel.getColumns().isEmpty()) {
                                        tableColumnMap.put(DlineageUtil.getIdentifierNormalTableName(tableModel.getFullName()),
                                                        tableModel.getColumns());
                                } else {
                                        tableColumnMap.put(DlineageUtil.getIdentifierNormalTableName(tableModel.getFullName()), null);
                                }
                        }
                }

                if (stmt.getSubQuery() != null) {
                        analyzeSelectStmt(stmt.getSubQuery());
                }

                Iterator<Table> tableIter = inserTables.iterator();
                while (tableIter.hasNext()) {
                        Table tableModel = tableIter.next();
                        List<TableColumn> tableColumns = tableColumnMap.get(DlineageUtil.getIdentifierNormalTableName(tableModel.getFullName()));
                        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.getName().endsWith("*")) {
                                                                starColumnCount += 1;
                                                        }
                                                }
                                                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);
                                                                if (!resultSetModel.getColumns().get(j).getName().contains("*")) {
                                                                        j++;
                                                                } else {
                                                                        starIndex++;
                                                                        if (resultSetSize - j == 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;
//                                                              }
//                                                      }
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(effectType);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        if (resultColumn.hasStarLinkColumn()
                                                                                        && resultColumn.getStarLinkColumnNames().size() > starIndex - 1 && starColumnCount<=1) {
                                                                                boolean find = false;
                                                                                while (resultColumn.getStarLinkColumnNames().size() > 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(new ResultColumnRelationshipElement(resultColumn));
                                                                                itemNames.add(resultColumn.getName());
                                                                        }
                                                                        Process process = modelFactory.createProcess(stmt);
                                                                        relation.setProcess(process);
                                                                }
                                                        }
                                                } else {
                                                        List<TableColumn> columns = tableModel.getColumns();
                                                        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.getStarLinkColumnNames().size() > 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 {
                                                                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.getName().contains("*")) {
                                                                                if (resultColumn.getName().equals(resultColumn.getRefColumnName())
                                                                                                && resultColumn.getColumnObject().toString().endsWith("*")
                                                                                                && 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.getStarLinkColumnNames().size() > 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);
                                                                        }
                                                                }
                                                        }
                                                }
                                        } 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());
                                                                        }
                                                                        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);
                                                        } 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);

                                                                } 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 (fieldAttr.toString().endsWith("*")) {
                                                                                                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 = modelFactory.createInsertTableColumn(tableModel, resultColumns.get(key).getName());
                                                                                                        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 (!"*".equals(getColumnName(tableColumn.getColumnObject()))
                                                                                        && "*".equals(getColumnName(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 || "*".equals(getColumnName(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 || "*".equals(getColumnName(columnName))) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        resultColumn.bindStarLinkColumn(columnName);
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }

                                                                        if ("*".equals(getColumnName(tableColumn.getColumnObject())) && resultColumn != null
                                                                                        && !resultColumn.getStarLinkColumns().isEmpty()) {
                                                                                tableColumn.bindStarLinkColumns(resultColumn.getStarLinkColumns());
                                                                        }

                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(effectType);
                                                                        relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(resultColumn));

                                                                        if (tableColumn.getName().endsWith("*") && resultColumn.getName().endsWith("*")) {
                                                                                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 = sqlenv.getSQLSchema(
                                                                                                        tableModel.getDatabase() + "." + tableModel.getSchema(), true);
                                                                                        if (schema != null) {
                                                                                                TSQLTable tempTable = schema.createTable(
                                                                                                                DlineageUtil.getSimpleTableName(tableModel.getName()));
                                                                                                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 = sqlenv.getSQLSchema(
                                                                                                        tableModel.getDatabase() + "." + tableModel.getSchema(), true);
                                                                                        if (schema != null) {
                                                                                                TSQLTable tempTable = schema.createTable(
                                                                                                                DlineageUtil.getSimpleTableName(tableModel.getName()));
                                                                                                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()));
                                                        }

                                                        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.getName().contains("*")) {
                                                                                if (resultColumn.getName().equals(resultColumn.getRefColumnName())
                                                                                                && resultColumn.getColumnObject().toString().endsWith("*")
                                                                                                && 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.getStarLinkColumnNames().size() > 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);
                                                                        }
                                                                }
                                                        }
                                                        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);
                                                                                                }
                                                                                        } 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.getProcedureByName(DlineageUtil
                                                        .getIdentifierNormalTableName(stmt.getExecuteStmt().getModuleName().toString()));
                                        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);
                                                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) {
                                String procedureName = DlineageUtil.getProcedureParentName(stmt);
                                String variableString = stmt.getRecordName().toString();
                                if (variableString.startsWith(":")) {
                                        variableString = variableString.substring(variableString.indexOf(":") + 1);
                                }
                                if (!SQLUtil.isEmpty(procedureName)) {
                                        variableString = procedureName + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                                }
                                
                                Table recordTable = modelManager
                                                .getTableByName(DlineageUtil.getTableFullName(variableString));
                                if (recordTable != null) {
                                        for (int i = 0; i < recordTable.getColumns().size(); i++) {
                                                TableColumn sourceTableColumn = recordTable.getColumns().get(i);
                                                TableColumn targetTableColumn = modelFactory.createTableColumn(tableModel,
                                                                sourceTableColumn.getColumnObject(), 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.getName().endsWith("*") && 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) {
                                Table cursor = modelManager.getTableByName(
                                                DlineageUtil.getTableFullName(stmt.getFunctionCall().getFunctionName().toString()));
                                if (cursor != null) {
                                        TObjectName starColumn = new TObjectName();
                                        starColumn.setString("*");
                                        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 = new TObjectName();
                                starColumn.setString("*");
                                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.getProcedureByName(DlineageUtil
                                                .getIdentifierNormalTableName(stmt.getExecuteStmt().getModuleName().toString()));
                                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.getName().endsWith("*")) {
                                                                                                        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.getName().endsWith("*")) {
                                                                                                        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.getName().endsWith("*")) {
                                                                                                        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.getName().endsWith("*")) {
                                                                                                        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);
                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                        relation.setEffectType(effectType);
                                        TObjectName starColumn = new TObjectName();
                                        starColumn.setString("*");
                                        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(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 (!expressions.isEmpty() && stmt.getSubQuery() != null) {
                        analyzeInsertImpactRelation(stmt.getSubQuery(), tableColumnMap, expressions, 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.getName().endsWith("*")) {
                                return column;
                        }
                }
                return null;
        }

        private boolean containStarColumn(List<TableColumn> columns) {
                if (columns == null)
                        return false;
                for (TableColumn column : columns) {
                        if (column.getName().endsWith("*")) {
                                return true;
                        }
                }
                return false;
        }

        private boolean containStarColumn(ResultSet resultSet) {
                if (resultSet == null || resultSet.getColumns() == null)
                        return false;
                for (ResultColumn column : resultSet.getColumns()) {
                        if (column.getName().endsWith("*")) {
                                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 analyzeInsertImpactRelation(TSelectSqlStatement stmt, Map<String, List<TableColumn>> insertMap,
                        List<TExpression> expressions, EffectType effectType) {
                List<TObjectName> objectNames = new ArrayList<TObjectName>();
                for (int i = 0; i < expressions.size(); i++) {
                        TExpression condition = expressions.get(i);
                        columnsInExpr visitor = new columnsInExpr();
                        condition.inOrderTraverse(visitor);
                        objectNames.addAll(visitor.getObjectNames());
                }

                Iterator<String> iter = insertMap.keySet().iterator();
                while (iter.hasNext()) {
                        String table = iter.next();
                        List<TableColumn> tableColumns = insertMap.get(table);
                        for (int i = 0; i < tableColumns.size(); i++) {

                                TableColumn column = tableColumns.get(i);
                                ImpactRelationship relation = modelFactory.createImpactRelation();
                                relation.setEffectType(effectType);
                                relation.setTarget(new TableColumnRelationshipElement(column));

                                for (int j = 0; j < objectNames.size(); j++) {
                                        TObjectName columnName = objectNames.get(j);
                                        Object model = modelManager.getModel(stmt);
                                        if (model instanceof SelectResultSet) {
                                                SelectResultSet queryTable = (SelectResultSet) model;
                                                List<ResultColumn> columns = queryTable.getColumns();
                                                for (int k = 0; k < columns.size(); k++) {
                                                        ResultColumn resultColumn = columns.get(k);
                                                        if (resultColumn.getAlias() != null
                                                                        && SQLUtil.compareIdentifier(option.getVendor(), ESQLDataObjectType.dotColumn, columnName.toString(), resultColumn.getAlias())) {
                                                                relation.addSource(
                                                                                new ResultColumnRelationshipElement(resultColumn, columnName.getLocation(), columnName));
                                                        } else if (resultColumn.getName() != null
                                                                        && SQLUtil.compareIdentifier(option.getVendor(), ESQLDataObjectType.dotColumn, columnName.toString(), resultColumn.getName())) {
                                                                relation.addSource(
                                                                                new ResultColumnRelationshipElement(resultColumn, columnName.getLocation(), columnName));
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        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 (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) {
                                                                targetColumn = queryTable.getColumns().get(j);
                                                        } else {
                                                                targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                                        }
                                                        for (Set<TObjectName> starLinkColumns : sourceColumn.getStarLinkColumns().values()) {
                                                                for (TObjectName starLinkColumn : starLinkColumns) {
                                                                        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) {
                                                                targetColumn = queryTable.getColumns().get(j);
                                                        } else {
                                                                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 {
                                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 = 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.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;
                                                }

                                                ResultColumn resultColumn = resultSetModel.getColumns().get(j);
                                                TObjectName targetColumn = getCteBaseColumn(cteTargetResolution, column);
                                                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(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.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();
                                        ResultColumn resultColumn = resultSetModel.getColumns().get(0);
                                        TObjectName targetColumn = getCteBaseColumn(cteTargetResolution, column);
                                        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(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()));
                                        }
                                }
                        }
                }

                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.getTableFullName(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;
                                }
                                for (int i = 0; i < viewColumnSize && j < resultSetSize; i++) {
                                        ResultColumn resultColumn = resultSetModel.getColumns().get(j);                                 
                                        if (i < viewItemSize) {
                                                TObjectName alias = viewItems.getViewAliasItem(i).getAlias();

                                                if (!resultSetModel.getColumns().get(j).getName().contains("*")) {
                                                        j++;
                                                } else {
                                                        if (resultSetSize - j == viewItems.size() - i) {
                                                                j++;
                                                        }
                                                }

                                                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(new ResultColumnRelationshipElement(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.getStarLinkColumns().isEmpty()) {
                                                                viewColumn.bindStarLinkColumns(column.getStarLinkColumns());
                                                        }
                                                        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);
                                                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());
                                                        if ("*".equals(viewColumnObject.getColumnNameOnly())) {
                                                                if (model instanceof LinkedHashMap) {
                                                                        String columnName = getColumnNameOnly(resultColumn.getName());
                                                                        LinkedHashMap<String, ResultColumn> resultColumns = (LinkedHashMap<String, ResultColumn>) model;
                                                                        if ("*".equals(columnName)) {
                                                                                for (String key : resultColumns.keySet()) {
                                                                                        ResultColumn column = resultColumns.get(key);
                                                                                        viewColumn = modelFactory.createInsertTableColumn(viewModel, column.getName());
                                                                                        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.getName());
                                                                                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);
                                                                object.setPartToken(viewColumnObject.getPropertyToken());
                                                                object.setStartToken(viewColumnObject.getPropertyToken());
                                                                object.setEndToken(viewColumnObject.getPropertyToken());
                                                                viewColumn = modelFactory.createViewColumn(viewModel, object, i, determined);
                                                        } 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.getStarLinkColumns().isEmpty()) {
                                                                        viewColumn.bindStarLinkColumns(column.getStarLinkColumns());
                                                                }
                                                                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.getName().endsWith("*") && resultColumn.getName().endsWith("*")) {
                                                                        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) {
                                                TableColumn viewColumn = modelFactory.createViewColumn(viewModel,
                                                                (TObjectName) resultColumn.getColumnObject(), 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.getStarLinkColumns().isEmpty()) {
                                                                viewColumn.bindStarLinkColumns(column.getStarLinkColumns());
                                                        }
                                                        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<String> appendStarColumns = new HashSet<String>();
        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();
                                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 ("*".equals(targetColumn.getName())) {
                                                                updateResultColumnStarLinks(dataflow, relation, -1);
                                                        }

                                                        if (targetColumn.hasStarLinkColumn()) {
                                                                for (int j = 0; j < targetColumn.getStarLinkColumnNames().size(); j++) {
                                                                        appendStarRelation(dataflow, relation, j);
                                                                }

                                                                if (!containsStar(relation.getSources())) {
                                                                        continue;
                                                                }
                                                        }
                                                }
                                                else {
                                                        String columnName = DlineageUtil.getColumnName(targetColumnName);
                                                        int index = targetColumn.getStarLinkColumnNames().indexOf(columnName);
                                                        if (index != -1) {
                                                                int size = targetColumn.getStarLinkColumnNames().size();
                                                                if ("*".equals(targetColumn.getName())) {
                                                                        if (appendStarColumns.contains(columnName)) {
                                                                                updateResultColumnStarLinks(dataflow, relation, index);
                                                                        }
                                                                        else {
                                                                                updateResultColumnStarLinks(dataflow, relation, -1);
                                                                                appendStarColumns.add(columnName);
                                                                        }
                                                                }
                                                                appendStarRelation(dataflow, relation, index);
                                                                for(int j= size; j < targetColumn.getStarLinkColumnNames().size(); j++) {
                                                                        appendStarRelation(dataflow, relation, j);
                                                                }
                                                                if (!containsStar(relation.getSources())) {
                                                                        continue;
                                                                }
                                                        }
                                                }
                                        }
                                } else if (targetElement instanceof TableColumn) {
                                        TableColumn targetColumn = (TableColumn) targetElement;
                                        if (!targetColumn.isPseduo()) {
                                                if ("*".equals(targetColumn.getName())) {
                                                        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.getStarLinkColumnNames().size(); 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(SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, column.getName(), targetObjectName)) {
                                                                                                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;
                                                                                }
                                                                        }
                                                                        if (sourceColumn.getStarLinkColumns().containsKey(targetObjectName)) {
                                                                                source = new sourceColumn();
                                                                                source.setId(String.valueOf(sourceColumn.getId()) + "_"
                                                                                                + sourceStarColumnNames.indexOf(targetObjectName));
                                                                                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);
                                                                        } 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));
                                                                                        if (sourceColumn.getStarLinkColumns().containsKey(objectName)) {

                                                                                                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(), objectName)) {
                                                                                                                        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()) + "_"
                                                                                                                + sourceStarColumnNames.indexOf(objectName));
                                                                                                source.setColumn(objectName);
                                                                                        } 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 = getColumnName(targetName);
                                                                        boolean find = false;
                                                                        
                                                                        if (!find && sourceColumn.getStarLinkColumns().containsKey(objectName)) {
                                                                                source.setId(String.valueOf(sourceColumn.getId()) + "_"
                                                                                                + sourceStarColumnNames.indexOf(objectName));
                                                                                source.setColumn(objectName);
                                                                                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(), objectName)) {
                                                                                                        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;
                                                                                        }
                                                                                }
                                                                                
                                                                                if (sourceColumn.getStarLinkColumns().containsKey(objectName)) {
                                                                                        source.setId(String.valueOf(sourceColumn.getId()) + "_"
                                                                                                        + sourceStarColumnNames.indexOf(objectName));
                                                                                        source.setColumn(objectName);
                                                                                        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;
                                                                                }
                                                                        }

                                                                        if (!find) {
                                                                                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 {
                                                        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.getStarLinkColumns().size() > 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 = getColumnName(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()) {
                                                                                if (column.getName() != null && SQLUtil.sameName(option.getVendor(), ESQLDataObjectType.dotColumn, column.getName(), objectName)) {
                                                                                        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.getName().endsWith("*") && object.isShowStar())
                                        return true;
                        } else if (element.getElement() instanceof TableColumn) {
                                TableColumn object = (TableColumn) element.getElement();
                                if (object.getName().endsWith("*") && 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, Set<String>> explicitStarTargetColumns = new HashMap<Long, Set<String>>();
        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()) {
                        for (Map.Entry<String, Set<TObjectName>> item : source.getStarLinkColumns().entrySet()) {
                            if (!targetColumn.getStarLinkColumns().containsKey(item.getKey())) {
                                targetColumn.getStarLinkColumns().put(item.getKey(), new LinkedHashSet<TObjectName>());
                            }
                            targetColumn.getStarLinkColumns().get(item.getKey()).addAll(item.getValue());
                        }
                        if (!source.isShowStar()) {
                            targetColumn.setShowStar(false);
                            relation.setShowStarRelation(false);
                        }
                    } else if (!"*".equals(source.getName())) {
                        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 = new TObjectName();
                                if (sourceColumn.getExpr().getExpressionType() == EExpressionType.typecast_t) {
                                    column.setString(sourceColumn.getExpr().getLeftOperand().toString());
                                } else {
                                    column.setString(sourceColumn.toString());
                                }
                                targetColumn.bindStarLinkColumn(column);
                            }
                        }
                    }
                } else if (sourceElement instanceof TableColumn && !targetColumn.isStruct()) {
                    TableColumn source = (TableColumn) sourceElement;
                    if (!source.isPseduo() && source.hasStarLinkColumn()) {
                                                for (Map.Entry<String, Set<TObjectName>> item : source.getStarLinkColumns().entrySet()) {
                                                        if (!targetColumn.getStarLinkColumns().containsKey(item.getKey())) {
                                                                targetColumn.getStarLinkColumns().put(item.getKey(),
                                                                                new LinkedHashSet<TObjectName>());
                                                        }
                                                        targetColumn.getStarLinkColumns().get(item.getKey()).addAll(item.getValue());
                                                }
                                                if ((source.getTable().isCreateTable() || source.getTable().hasSQLEnv())
                                                                && !source.isShowStar()) {
                                                        targetColumn.setShowStar(false);
                                                        relation.setShowStarRelation(false);
                                                }
                    } else if (!"*".equals(source.getName())) {
                        targetColumn.bindStarLinkColumn(source.getColumnObject());
                    }
                }
            }

            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.getName() != null && item.getName().endsWith("*")) {
                        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.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 (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName())
                                            .equals(columnName)) {
                                        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.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 (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals(columnName)) {
                                    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()) {
                                        for (Map.Entry<String, Set<TObjectName>> item : source.getStarLinkColumns().entrySet()) {
                                                if (!targetColumn.getStarLinkColumns().containsKey(item.getKey())) {
                                                        targetColumn.getStarLinkColumns().put(item.getKey(), new LinkedHashSet<TObjectName>());
                                                }
                                                targetColumn.getStarLinkColumns().get(item.getKey()).addAll(item.getValue());
                                        }
                                        if (!source.isShowStar()) {
                                                targetColumn.setShowStar(false);
                                                relation.setShowStarRelation(false);
                                        }
                                } else if (!"*".equals(source.getName())) {
                                        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 = new TObjectName();
                                                                if (((TResultColumn) source.getColumnObject()).getExpr()
                                                                                .getExpressionType() == EExpressionType.typecast_t) {
                                                                        column.setString(((TResultColumn) source.getColumnObject()).getExpr()
                                                                                        .getLeftOperand().toString());
                                                                } else {
                                                                        column.setString(((TResultColumn) source.getColumnObject()).toString());
                                                                }
                                                                targetColumn.bindStarLinkColumn(column);
                                                        }
                                                }
                                        }
                                }
                        } else if (sourceElement instanceof TableColumn) {
                                TableColumn source = (TableColumn) sourceElement;
                                if (source.hasStarLinkColumn()) {
                                        for (Map.Entry<String, Set<TObjectName>> item : source.getStarLinkColumns().entrySet()) {
                                                if (!targetColumn.getStarLinkColumns().containsKey(item.getKey())) {
                                                        targetColumn.getStarLinkColumns().put(item.getKey(), new LinkedHashSet<TObjectName>());
                                                }
                                                targetColumn.getStarLinkColumns().get(item.getKey()).addAll(item.getValue());
                                        }
                                        for (Map.Entry<String, Set<TObjectName>> item : targetColumn.getStarLinkColumns().entrySet()) {
                                                if (!source.getStarLinkColumns().containsKey(item.getKey())) {
                                                        source.getStarLinkColumns().put(item.getKey(), new LinkedHashSet<TObjectName>());
                                                }
                                                source.getStarLinkColumns().get(item.getKey()).addAll(item.getValue());
                                        }

                                        sourceStarColumn = source;

                                        if (source.getTable().isCreateTable() && !source.isShowStar()) {
                                                targetColumn.setShowStar(false);
                                                relation.setShowStarRelation(false);
                                        }
                                } else if (!"*".equals(source.getName())) {
                                        if (source.isStruct()) {
                                                targetColumn.bindStarLinkColumn(source.getColumnObject());
                                        }
                                        else {
                                                TObjectName objectName = new TObjectName();
                                                objectName.setString(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 = new ArrayList<String>(targetColumn.getStarLinkColumns().keySet());
                                for (int k = 0; k < columns.size(); k++) {
                                        String columnName = columns.get(k);
                                        if (containStarColumn(targetColumn.getTable().getColumns(), columnName)) {
                                                continue;
                                        }
                                        column columnElement = new column();
                                        columnElement.setId(String.valueOf(targetColumn.getId()) + "_" + 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 = new ArrayList<String>(sourceStarColumn.getStarLinkColumns().keySet());
                                for (int k = 0; k < columns.size(); k++) {
                                        String columnName = columns.get(k);
                                        if (containStarColumn(sourceStarColumn.getTable().getColumns(), columnName)) {
                                                continue;
                                        }
                                        column columnElement = new column();
                                        columnElement.setId(sourceStarColumn.getId() + "_" + 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 = "";

                if (targetElement instanceof ResultColumn) {
                        ResultColumn targetColumn = (ResultColumn) targetElement;

                        targetName = targetColumn.getStarLinkColumnNames().get(index);

                        
                        targetColumn target = new targetColumn();
                        target.setId(String.valueOf(targetColumn.getId()) + "_" + index);
                        if(targetColumn.getResultSet()!=null && targetColumn.getResultSet().getColumns()!=null) {
                                Map<String, ResultColumn> lookup = getResultSetColumnLookup(targetColumn.getResultSet().getColumns());
                                ResultColumn matched = lookup.get(targetName);
                                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;

                        targetName = targetColumn.getStarLinkColumnNames().get(index);

                        Map<String, TableColumn> tableLookup = getTableColumnLookup(targetColumn.getTable().getColumns());
                        TableColumn tableColumn = tableLookup.get(targetName);

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

                String targetIdentifierName = DlineageUtil.getIdentifierNormalColumnName(targetName);
                if (targetIdentifierName == 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, targetIdentifierName);
                        if (hasDefinitiveExplicitSource) {
                                if (!explicitStarTargetColumns.containsKey(targetColumnId)) {
                                        explicitStarTargetColumns.put(targetColumnId, new HashSet<String>());
                                }
                                explicitStarTargetColumns.get(targetColumnId).add(targetIdentifierName);
                        }
                }

                // Column names that have explicit (non-star) sources for this target, across all relationships
                Set<String> 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 (!targetIdentifierName.equalsIgnoreCase(sourceName) && !"*".equals(sourceName))
                                                                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(sourceName)) {
                                                        continue;
                                                }
                                                sourceColumn source = new sourceColumn();                                               
                                                
                                                boolean find = false;
                                                if(sourceColumn.getResultSet()!=null && sourceColumn.getResultSet().getColumns()!=null) {
                                                        Map<String, ResultColumn> srcLookup = getResultSetColumnLookup(sourceColumn.getResultSet().getColumns());
                                                        ResultColumn matched = srcLookup.get(sourceName);
                                                        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(targetIdentifierName))
                                                && sourceColumn.getResultSet()!=null && sourceColumn.getResultSet().getColumns()!=null) {
                                                Map<String, ResultColumn> srcLookup = getResultSetColumnLookup(sourceColumn.getResultSet().getColumns());
                                                for (Map.Entry<String, ResultColumn> entry : srcLookup.entrySet()) {
                                                        if (entry.getKey().equalsIgnoreCase(targetIdentifierName)) {
                                                                ResultColumn columnModel = entry.getValue();
                                                                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;
                                                        }
                                                }
                                        }
                                        if (relationElement.getSources().isEmpty()
                                                && !(targetExplicitNames != null && targetExplicitNames.contains(targetIdentifierName))) {
                                                TObjectName sourceStarLinkColumn = new TObjectName();
                                                sourceStarLinkColumn.setString(targetName);
                                                boolean newBinding = sourceColumn.bindStarLinkColumn(sourceStarLinkColumn);
                                                sourceColumn source = new sourceColumn();
                                                String sourceName = DlineageUtil.getColumnName(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.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 (!targetIdentifierName
                                                                .equalsIgnoreCase(DlineageUtil.getIdentifierNormalColumnName(sourceColumn.getName()))) {
                                                        if (!"*".equals(sourceColumn.getName())) {
                                                                // 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 {
                                                                Map<String, ResultColumn> srcLookup = getResultSetColumnLookup(sourceColumn.getResultSet().getColumns());
                                                                boolean flag = false;
                                                                for (String key : srcLookup.keySet()) {
                                                                        if (targetIdentifierName.equalsIgnoreCase(key)) {
                                                                                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 (!targetIdentifierName.equalsIgnoreCase(sourceName) && !"*".equals(sourceName))
                                                                continue;
                                                }

                                                Map<String, TableColumn> srcTableLookup = getTableColumnLookup(sourceColumn.getTable().getColumns());
                                                TableColumn tableColumn = srcTableLookup.get(sourceName);

                                                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, sourceName)) {
                                                        continue;
                                                }
                                                // Cross-relationship check: skip if explicit source was found in prior relationship
                                                if (targetExplicitNames != null && targetExplicitNames.contains(sourceName)) {
                                                        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(), sourceName)) {
                                                                        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 (!targetIdentifierName
                                                                .equalsIgnoreCase(DlineageUtil.getIdentifierNormalColumnName(sourceColumn.getName()))
                                                                && !"*".equals(sourceColumn.getName())) {
                                                        // 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);
                }
        }

        private String getColumnName(TObjectName column) {
                if (column == null) {
                        return null;
                }
                String name = column.getColumnNameOnly();
                if (name == null || "".equals(name.trim())) {
                        return DlineageUtil.getIdentifierNormalColumnName(column.toString().trim());
                } else
                        return DlineageUtil.getIdentifierNormalColumnName(name.trim());
        }

        /**
         * For BigQuery/Redshift struct field access, returns the full struct path
         * (e.g., "customer.name" from ColumnSource with exposedName="customer", fieldPath=["name"]).
         * Checks StructFieldHint first (for 3+ part no-alias), then ColumnSource (for 2-part/alias).
         * Returns null if this is not a struct field access.
         */
        private String getStructFieldFullName(TObjectName column) {
                if (column == null) return null;
                if (getOption().getVendor() != EDbVendor.dbvbigquery
                        && getOption().getVendor() != EDbVendor.dbvredshift) return null;
                // Priority 1: StructFieldHint (side-channel, for 3+ part no-alias deep struct access)
                gudusoft.gsqlparser.resolver2.model.StructFieldHint hint = column.getStructFieldHint();
                if (hint != null && hint.getFieldPath() != null && !hint.getFieldPath().isEmpty()) {
                        return hint.toFullReference();
                }
                // Priority 2: ColumnSource (main resolution, for 2-part and alias cases)
                gudusoft.gsqlparser.resolver2.model.ColumnSource source = column.getColumnSource();
                if (source != null && source.isStructFieldAccess() && source.hasFieldPath()) {
                        return source.getFieldPath().toFullReference(source.getExposedName());
                }
                return null;
        }

        /**
         * Get the base column name for a struct field access column.
         * Checks StructFieldHint first (3+ part no-alias), then ColumnSource (2-part/alias).
         * Returns null if not a struct field access.
         */
        private String getStructFieldBaseName(TObjectName column) {
                if (column == null) return null;
                gudusoft.gsqlparser.resolver2.model.StructFieldHint hint = column.getStructFieldHint();
                if (hint != null && hint.getBaseColumn() != null) {
                        return hint.getBaseColumn();
                }
                gudusoft.gsqlparser.resolver2.model.ColumnSource source = column.getColumnSource();
                if (source != null && source.isStructFieldAccess()) {
                        return source.getExposedName();
                }
                return null;
        }

        private String getColumnName(String column) {
                if (column == null) {
                        return null;
                }
                String name = column.substring(column.lastIndexOf(".") + 1).trim();
                if (name.length() == 0) {
                        name = column.trim();
                }
                // Memoize the normalization. DlineageUtil.getIdentifierNormalColumnName(name)
                // resolves the vendor from ModelBindingManager.getGlobalVendor() internally,
                // so the result is a pure function of (vendor, name) — NOT of name alone.
                // The cache key therefore includes the vendor; passing it explicitly to the
                // 2-arg overload is identical to the original call for that same vendor.
                EDbVendor vendor = ModelBindingManager.getGlobalVendor();
                String cacheKey = (vendor == null ? "" : vendor.name()) + ":" + name;
                String normalized = normalizedColumnNameCache.get(cacheKey);
                if (normalized == null) {
                        normalized = DlineageUtil.getIdentifierNormalColumnName(name, vendor);
                        if (normalized != null) {
                                normalizedColumnNameCache.put(cacheKey, normalized);
                        }
                }
                return normalized;
        }
        
        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();
                                        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 {
                                        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();
                                                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(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 ((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);

                List<ResultColumn> columns = resultSetModel.getColumns();

                Map<String, Integer> columnCounts = new HashMap<String, Integer>();
                for (ResultColumn column : columns) {
                        String columnName = DlineageUtil.getIdentifierNormalColumnName(column.getName());
                        if (!columnCounts.containsKey(columnName)) {
                                columnCounts.put(columnName, 0);
                        }
                        columnCounts.put(columnName, columnCounts.get(columnName) + 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());
                                        if (columnModel.isFunction()) {
                                                columnElement.setIsFunction(String.valueOf(columnModel.isFunction()));
                                        }
                                        if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                                columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                                + convertCoordinate(columnModel.getEndPosition()));
                                        }

                                        String identifier = DlineageUtil.getIdentifierNormalColumnName(columnModel.getName());
                                        if (columnCounts.containsKey(identifier) && columnCounts.get(identifier) > 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());
                                if (columnModel.isFunction()) {
                                        columnElement.setIsFunction(String.valueOf(columnModel.isFunction()));
                                }
                                if (columnModel.getStartPosition() != null && columnModel.getEndPosition() != null) {
                                        columnElement.setCoordinate(convertCoordinate(columnModel.getStartPosition()) + ","
                                                        + convertCoordinate(columnModel.getEndPosition()));
                                }

                                String identifier = DlineageUtil.getIdentifierNormalColumnName(columnModel.getName());
                                if (columnCounts.containsKey(identifier) && columnCounts.get(identifier) > 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;

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

                // 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());
                        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) {
                type = DlineageUtil.getIdentifierNormalTableName(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.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.getName().endsWith("*")) {
                                        for (TableColumn starElement : columns) {
                                                if (starElement == column) {
                                                        continue;
                                                }
                                                TObjectName columnObject = starElement.getColumnObject();
                                                column.bindStarLinkColumn(columnObject);
                                        }
                                        if (viewModel.isCreateTable()) {
                                                column.setShowStar(false);
                                        }
                                }
                        }
                }

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = (TableColumn) columns.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);
                                        String columnName = starLinkColumnList.get(k);
                                        if (containStarColumn(columns, columnName)) {
                                                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());
                                        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());
                                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()));
                        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()));
                        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()));
                        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()));
                        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()));
                        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()));
                        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);
                }
        }

        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.getName());

                dataflow.getPaths().add(pathElement);

                List<TableColumn> columns = pathModel.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()));
                        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.getName().endsWith("*")) {
                                        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);
                                        String columnName = starLinkColumnList.get(k);
                                        if (containStarColumn(columns, columnName)) {
                                                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());
                                        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());
                                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.getName().endsWith("*")) {
                                        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);
                                        String columnName = starLinkColumnList.get(k);
                                        if (containStarColumn(columns, columnName)) {
                                                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());
                                        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());
                                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()));
                        }

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

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

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

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

                        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<String, table> tableMap = new HashMap<String, 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());
                        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) {
                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<String, table> tableMap) {
                if(tableModel.getSubType() == SubType.unnest) {}
                table tableElement = new table();
                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;
                String tableFullName = DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getQualifiedTableName(tableElement));
                
                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.getName().endsWith("*")) {
                                        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);
                                        }
                                }
                        }
                }

                for (int j = 0; j < columns.size(); j++) {
                        TableColumn columnModel = columns.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);
                                        String columnName = starLinkColumnList.get(k);
                                        if (containStarColumn(columns, columnName)) {
                                                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());
                                        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());
                                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);
                }
        }

        private boolean containStarColumn(List<TableColumn> columns, String qualifiedColumnName) {
                for (TableColumn tableColumn : columns) {
                        if (DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()).equals(qualifiedColumnName)) {
                                return true;
                        }
                }
                return false;
        }

        private TableColumn searchTableColumn(List<TableColumn> columns, String qualifiedColumnName) {
                for (TableColumn tableColumn : columns) {
                        if (DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()).equals(qualifiedColumnName)) {
                                return tableColumn;
                        }
                }
                return null;
        }

        private boolean containStarColumn(Collection<RelationshipElement<?>> elements, String qualifiedColumnName) {
                for (RelationshipElement element : elements) {
                        if (element.getElement() instanceof TableColumn) {
                                if (DlineageUtil.getIdentifierNormalColumnName(((TableColumn) element.getElement()).getName())
                                                .equals(qualifiedColumnName)) {
                                        return true;
                                }
                        } else if (element.getElement() instanceof ResultColumn) {
                                if (DlineageUtil.getIdentifierNormalColumnName(((ResultColumn) element.getElement()).getName())
                                                .equals(qualifiedColumnName)) {
                                        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, String qualifiedColumnName) {
                // 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 ("*".equals(tc.getName()) && tc.getTable() != null) {
                                        starSourceParentIds.add(tc.getTable().getId());
                                }
                        } else if (element.getElement() instanceof ResultColumn) {
                                ResultColumn rc = (ResultColumn) element.getElement();
                                if ("*".equals(rc.getName()) && 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 (!"*".equals(tc.getName())
                                                && DlineageUtil.getIdentifierNormalColumnName(tc.getName()).equals(qualifiedColumnName)) {
                                        if (tc.getTable() != null && !starSourceParentIds.contains(tc.getTable().getId())) {
                                                return true;
                                        }
                                }
                        } else if (element.getElement() instanceof ResultColumn) {
                                ResultColumn rc = (ResultColumn) element.getElement();
                                if (!"*".equals(rc.getName())
                                                && DlineageUtil.getIdentifierNormalColumnName(rc.getName()).equals(qualifiedColumnName)) {
                                        if (rc.getResultSet() != null && !starSourceParentIds.contains(rc.getResultSet().getId())) {
                                                return true;
                                        }
                                }
                        }
                }
                return false;
        }

        private void analyzeSelectStmt(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();
                        for (int i = 0; i < columns.size(); i++) {
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.select);
                                relation.setTarget(new ResultColumnRelationshipElement(columns.get(i)));

                                if (!stmt.getLeftStmt().isCombinedQuery()) {
                                        ResultSet sourceResultSet = (ResultSet) modelManager
                                                        .getModel(stmt.getLeftStmt().getResultColumnList());
                                        if (sourceResultSet!=null && sourceResultSet.getColumns().size() > i) {
                                                if (columns.get(i).getName().endsWith("*")) {
                                                        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).getName().endsWith("*")) {
                                                        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).getName().endsWith("*")) {
                                                        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));
                                                        }
                                                }
                                        }
                                }
                        }
                        
                        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++) {
                                                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.getLateralViewList() != null && !table.getLateralViewList().isEmpty()) {
                                        analyzeTableSubquery(table);
                                        analyzeLateralView(stmt, table, table.getLateralViewList());
                                        stmtStack.pop();
                                        return;
                                }
                                if (table.getUnnestClause() != null && option.getVendor() == EDbVendor.dbvpresto) {
                                        analyzeTableSubquery(table);
                                        analyzePrestoUnnest(stmt, table);
                                        stmtStack.pop();
                                        return;
                                }
                                if (table.getUnnestClause() != null && option.getVendor() == EDbVendor.dbvbigquery) {
                                        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);
                                // 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.getProcedureByName(
                                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                        if (callee == null && procedureDDLMap.containsKey(DlineageUtil.getFunctionNameWithArgNum(functionCall))) {
                                                analyzeCustomSqlStmt(procedureDDLMap.get(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                                callee = modelManager.getProcedureByName(
                                                                DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionCall)));
                                        }

                                        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.getFunctionTable(DlineageUtil
                                                                .getIdentifierNormalTableName(functionCall.getFunctionName().toString()));
                                                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.getFunctionTable(DlineageUtil
                                                                .getIdentifierNormalTableName(functionCall.getFunctionName().toString()));
                                                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);
                                                                                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()));
                                        }

                                        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));
                                                }
                                        }
                                } 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;
                                                        for (int j = 0; 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++;
                                                                                if (resultSetModel.getColumns().get(j).getName().contains("*")
                                                                                                && x < cteColumns.size()) {
                                                                                        j--;
                                                                                }
                                                                        }
                                                                } else {
                                                                        targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                                                }
                                                                for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                        targetColumn.bindStarLinkColumn(starLinkColumn);
                                                                }
                                                                createCteSelectRelation(null, targetColumn, sourceColumn);
                                                        }
                                                        if (!queryTable.isDetermined()) {
                                                                queryTable.setDetermined(selectSetResultSetModel.isDetermined());
                                                        }
                                                } else {
                                                        int x = 0;
                                                        for (int j = 0; j < resultSetModel.getColumns().size(); j++) {
                                                                ResultColumn sourceColumn = resultSetModel.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++;
                                                                                if (resultSetModel.getColumns().get(j).getName().contains("*")
                                                                                                && x < cteColumns.size()) {
                                                                                        j--;
                                                                                }
                                                                        }
                                                                } else {
                                                                        targetColumn = modelFactory.createSelectSetResultColumn(queryTable, sourceColumn);
                                                                }
                                                                for (TObjectName starLinkColumn : sourceColumn.getStarLinkColumnList()) {
                                                                        targetColumn.bindStarLinkColumn(starLinkColumn);
                                                                }
                                                                createCteSelectRelation(null, targetColumn, sourceColumn);
                                                        }
                                                        if (!queryTable.isDetermined()) {
                                                                queryTable.setDetermined(resultSetModel.isDetermined());
                                                        }
                                                }
                                        } 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.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();
                                                                        columnName.setString("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 (!"*".equals(getColumnName(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 ("*".equals(getColumnName(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);
                                }
                        }

                        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<String> columnNames = new HashSet<String>();
                                                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
                                                                                        .getTableByName(DlineageUtil.getTableFullName(columnObject.toString()));
                                                                        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.createVariable(columnObject);
                                                                                variable.setCreateTable(true);
                                                                                variable.setSubType(SubType.record);
                                                                                TObjectName variableProperties = new TObjectName();
                                                                                variableProperties.setString("*");
                                                                                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 (column.getExpr().getFunctionCall() != null && column.getExpr().getFunctionCall().getFunctionType() == EFunctionType.struct_t) {
                                                                        Function function = (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);
                                                                                DataFlowRelationship relationship = modelFactory.createDataFlowRelation();
                                                                                relationship.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relationship.addSource(
                                                                                                new ResultColumnRelationshipElement(function.getColumns().get(j)));
                                                                        }
                                                                } 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());
                                                                                for (int z = 0; z < table.getColumns().size(); z++) {
                                                                                        TableColumn tableColumn = table.getColumns().get(z);
                                                                                        if(getColumnName(exprColumnName.toString()).equals(getColumnName(tableColumn.getName()))) {
                                                                                                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 {
                                                                                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());
                                                                                                for (int z = 0; z < table.getColumns().size(); z++) {
                                                                                                        TableColumn tableColumn = table.getColumns().get(z);
                                                                                                        if(getColumnName(exprColumnName.toString()).equals(getColumnName(tableColumn.getName()))) {
                                                                                                                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 ("*".equals(column.getColumnNameOnly())) {
                                                                                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()];
                                                                                        for (int k = 0; k < sourceTables.size(); k++) {
                                                                                                TTable sourceTable = sourceTables.get(k);
                                                                                                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(getColumnName(objectName.toString()).equals(getColumnName(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 (getColumnName(objectName.toString())
                                                                                                                                                                .equals(getColumnName(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 = DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName());
                                                                                                                        //bigquery
                                                                                                                        boolean exist = false;
                                                                                                                        if (!columnName.matches("(?i)f\\d+_")) {
                                                                                                                                if (!keyMap.containsKey(columnName)) {
                                                                                                                                        keyMap.put(columnName, new AtomicInteger(0));
                                                                                                                                } else {
                                                                                                                                        while (columnNames.contains(columnName)) {
                                                                                                                                                if(columnName.indexOf("*") == -1 && stmt.toString().matches("(?is).*using\\s*\\(\\s*"+columnName+"\\s*\\).*")) {
                                                                                                                                                        exist = true;
                                                                                                                                                        break;
                                                                                                                                                } else if (keyMap.containsKey(columnName)) {
                                                                                                                                                        int index = keyMap.get(columnName)
                                                                                                                                                                        .incrementAndGet();
                                                                                                                                                        columnName = columnName + index;
                                                                                                                                                }
                                                                                                                                        }
                                                                                                                                }
                                                                                                                                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(), targetColumn))
                                                                                                                                                                .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).
                                                                                                                        if (DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName())
                                                                                                                                        .equalsIgnoreCase(DlineageUtil.getIdentifierNormalColumnName(columnName))) {
                                                                                                                                columnName = tableColumn.getName();
                                                                                                                        }
                                                                                                                        ResultColumn resultColumn = modelFactory.createStarResultColumn(resultSetModel, column, columnName);
                                                                                                                        resultColumn.setStruct(tableColumn.isStruct());
                                                                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                                                        relation.setEffectType(EffectType.select);
                                                                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                                                }
                                                                                                        }
                                                                                                        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(getColumnName(objectName.toString()).equals(getColumnName(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 (getColumnName(objectName.toString())
                                                                                                                                                                .equals(getColumnName(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());
                                                                                                                        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 = DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName());
                                                                                                                        //bigquery
                                                                                                                        if (!columnName.matches("(?i)f\\d+_")) {
                                                                                                                                if (!keyMap.containsKey(columnName)) {
                                                                                                                                        keyMap.put(columnName, new AtomicInteger(0));
                                                                                                                                } else {
                                                                                                                                        while (columnNames.contains(columnName)) {
                                                                                                                                                int index = keyMap.get(columnName)
                                                                                                                                                                .incrementAndGet();
                                                                                                                                                columnName = columnName + index;
                                                                                                                                        }
                                                                                                                                }
                                                                                                                                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).
                                                                                                                        if (DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName())
                                                                                                                                        .equalsIgnoreCase(DlineageUtil.getIdentifierNormalColumnName(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);
                                                                                                                                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 = modelFactory
                                                                                                                        .createResultColumn(resultSetModel, column);
                                                                                                        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
                                                                                                                                        || "*".equals(getColumnName(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;
                                                                                        }
                                                                                } 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 ("*".equals(getColumnName(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);
                                                                }
                                                        }
                                                }
                                                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);
                                                        if ("*".equals(column.getColumnNameOnly())) {
                                                                
                                                                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();
                                                                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 (getColumnName(objectName.toString())
                                                                                                                        .equals(getColumnName(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 (getColumnName(objectName.toString())
                                                                                                                                        .equals(getColumnName(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 {
                                                                                                ResultColumn resultColumn = modelFactory.createStarResultColumn(
                                                                                                                resultSetModel, column, tableColumn.getName());
                                                                                                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 (getColumnName(objectName.toString())
                                                                                                                        .equals(getColumnName(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 (getColumnName(objectName.toString())
                                                                                                                                        .equals(getColumnName(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(
                                                                                                                (ResultSet)queryModel, column, tableColumn.getRefColumnName());
                                                                                                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());
                                                                                                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.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 || "*".equals(getColumnName(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 ("*".equals(getColumnName(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 ("*".equals(getColumnName(starLinkColumn))) {
                                                                                                                        continue;
                                                                                                                }
                                                                                                                resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                                        }
                                                                                                } else if (item.getColumnObject() instanceof TObjectName) {
                                                                                                        TObjectName starLinkColumn = (TObjectName) item.getColumnObject();
                                                                                                        if ("*".equals(getColumnName(starLinkColumn))) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }

                                                                } else {
                                                                        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 ("*".equals(getColumnName(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);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                        else {
                                                                ResultColumn resultColumn = modelFactory.createResultColumn(resultSetModel, column);
                                                        }
                                                        analyzeResultColumn(column, EffectType.select);

                                                }
                                                
                                                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 ("*".equals(column.getColumnNameOnly())) {
                                                        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 (getColumnName(objectName.toString())
                                                                                                                        .equals(getColumnName(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 (getColumnName(objectName.toString())
                                                                                                                                        .equals(getColumnName(name))) {
                                                                                                                                except = true;
                                                                                                                                break;
                                                                                                                        }
                                                                                                                }
                                                                                                                if (except) {
                                                                                                                        break;
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                                if (except) {
                                                                                                        continue;
                                                                                                }
                                                                                        }
                                                                                        ResultColumn resultColumn = modelFactory.createStarResultColumn(
                                                                                                        resultSetModel, column, tableColumn.getName());
                                                                                        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 (stmt.getResultColumnList().getResultColumn(j).getColumnNameOnly()
                                                                                                                .endsWith("*")) {
                                                                                                        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 (getColumnName(objectName.toString())
                                                                                                                        .equals(getColumnName(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 (getColumnName(objectName.toString())
                                                                                                                                        .equals(getColumnName(name))) {
                                                                                                                                except = true;
                                                                                                                                break;
                                                                                                                        }
                                                                                                                }
                                                                                                                if (except) {
                                                                                                                        break;
                                                                                                                }
                                                                                                        }
                                                                                                }
                                                                                                if (except) {
                                                                                                        continue;
                                                                                                }
                                                                                        }
                                                                                        if (tableColumn.getRefColumnName() != null) {
                                                                                                ResultColumn resultColumn = modelFactory.createStarResultColumn(
                                                                                                                (ResultSet)queryModel, column, tableColumn.getRefColumnName());
                                                                                                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());
                                                                                                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 (stmt.getResultColumnList().getResultColumn(j).getColumnNameOnly()
                                                                                                                .endsWith("*")) {
                                                                                                        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 || "*".equals(getColumnName(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 || "*".equals(getColumnName(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 ("*".equals(getColumnName(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 (queryModel instanceof ResultSet) {
                                                boolean isDetermined = true;
                                                ResultSet resultSet = (ResultSet) queryModel;
                                                for (ResultColumn column : resultSet.getColumns()) {
                                                        if (column.getName().endsWith("*")) {
                                                                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) {
                                                                
                                                                ResultSet joinResultSet = (ResultSet) modelManager.getModel(table.getSubquery());
                                                                for (int x = 0; 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);
                                }
                        }

                        stmtStack.pop();
                }
        }

        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));
                        }
                }
                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 (DlineageUtil.compareColumnIdentifier(getColumnName(columnName),
                                                                getColumnName(SQLUtil.trimColumnStringQuote(column.getName())))) {
                                                        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);
                                        }
                                }
                        }
                }
        }

        protected boolean isStructColumn(TObjectName columnName) {
                return columnName.getSourceTable() != null && columnName.getSourceTable().getAliasClause() != null
                                && columnName.getSourceTable().getUnnestClause() != null
                                && DlineageUtil.compareColumnIdentifier(getColumnName(columnName),
                                                getColumnName(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 ("*".equals(column.getName())) {
                                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.getTableByName(
                                                                        DlineageUtil.getTableFullName(tableAlias.toString()));
                                                        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.createVariable(variableName);
                                                variable.setSubType(SubType.record);
                                                TObjectName variableProperties = new TObjectName();
                                                variableProperties.setString("*");
                                                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;

                                if (tableName.getDbObjectType() == EDbObjectType.variable) {
                                        if (tableName.toString().indexOf(".") != -1) {
                                                List<String> splits = SQLUtil.parseNames(tableName.toString());
                                                tableModel = modelFactory.createVariable(splits.get(splits.size() - 2));
                                                // 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.createVariable(tableName);
                                        }
                                        if (tableModel.getSubType() == null) {
                                                tableModel.setSubType(SubType.record);
                                        }
                                        if(variableColumn == null
                                                        && (tableModel.getColumns() == null || tableModel.getColumns().isEmpty())) {
                                                TObjectName variableProperties = new TObjectName();
                                                variableProperties.setString("*");
                                                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
                                                                && (tableName.getDbObjectType() == EDbObjectType.variable
                                                                                || 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.getName());
                                                        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()));
                                                                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());
                                        if(queryModel.isDetermined() && DlineageUtil.isTempTable(tableModel, option.getVendor())) {
                                                tableModel.setCreateTable(true, false);
                                        }
                                        if (j + 1 == tableNames.size()) {
                                                return;
                                        }
                                        continue;
                                }

                                boolean isDetermined = true;
                                for (int i = 0; i < stmt.getResultColumnList().size(); i++) {
                                        if (tableNames.size() > 1
                                                        && (tableName.getDbObjectType() == EDbObjectType.variable
                                                                        || oracleIntoTableColumn != null)) {
                                                if (i != j) {
                                                        continue;
                                                }
                                        }
                                        TResultColumn column = stmt.getResultColumnList().getResultColumn(i);

                                        if ("*".equals(column.getColumnNameOnly()) && 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 = modelFactory.createInsertTableColumn(tableModel,
                                                                                        sourceColumn.getName());
                                                                        fillSyntheticColumnPosition(tableColumn, sourceColumn);
                                                                }
                                                                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 = sqlenv.getSQLSchema(
                                                                                                tableModel.getDatabase() + "." + tableModel.getSchema(), true);
                                                                                if (schema != null) {
                                                                                        TSQLTable tempTable = schema.createTable(DlineageUtil.getSimpleTableName(tableModel.getName()));
                                                                                        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);
                                                                }
                                                        }
                                                }
                                        }
                                }
                                tableModel.setDetermined(isDetermined);
                                if(isDetermined && DlineageUtil.isTempTable(tableModel, option.getVendor())) {
                                        tableModel.setCreateTable(true, false);
                                }
                        }
                }
        }

        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 (getColumnName(columnName)
                                                                                .equals(DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                        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 (getColumnName(columnName)
                                                                                .equals(DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                        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 (getColumnName(columnName1).equals(
                                                                                        DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                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 (getColumnName(columnName1).equals(
                                                                                        DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                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 ("*".equals(getColumnName(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.getStarLinkColumns().remove(
                                                                                                                        getColumnName(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 = new TObjectName();
                                                                                                columnName.setString(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 (getColumnName(columnObject.getFieldAttr()).equals(
                                                                                        DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                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 (getColumnName(columnObject.getFieldAttr()).equals(
                                                                                        DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                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) {
                                                        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 (tableColumn.hasStarLinkColumn()) {
                                                                                for (int k = 0; k < tableColumn.getStarLinkColumnList().size(); k++) {
                                                                                        TObjectName objectName = tableColumn.getStarLinkColumnList().get(k);
                                                                                        if (getColumnName(columnName).equals(getColumnName(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.getStarLinkColumns()
                                                                                                                .remove(DlineageUtil.getColumnName(objectName));
                                                                                                find = true;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        } else if (getColumnName(columnName).equals(
                                                                                        DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                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.getName().endsWith("*")) {
                                                                                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 (getColumnName(columnName).equals(
                                                                                        DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                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 (getColumnName(columnName).equals(getColumnName(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.getStarLinkColumns()
                                                                                                                                .remove(DlineageUtil.getColumnName(objectName));
                                                                                                                break;
                                                                                                        }
                                                                                                }
                                                                                        } else if (getColumnName(columnName).equals(DlineageUtil
                                                                                                        .getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                                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 (getColumnName(columnName).equals(DlineageUtil
                                                                                                        .getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                                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 (getColumnName(columnName).equals(DlineageUtil
                                                                                                        .getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                                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 (getColumnName(columnName).equals(DlineageUtil
                                                                                                        .getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                                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 ("*".equals(getColumnName(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 (getColumnName(columnObject.getFieldAttr())
                                                                                .equals(DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                        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 (getColumnName(columnObject.getExpr().getRightOperand().getObjectOperand())
                                                                        .equals(DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                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 ("*".equals(getColumnName(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.getStarLinkColumns().remove(getColumnName(
                                                                                                                                        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 = new TObjectName();
                                                                                                                columnName.setString(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 = new TObjectName();
                                                                                        column1.setString(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
                                                                                                                        .getIdentifierNormalColumnName(tableColumn.getName()).equals(getColumnName(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 (getColumnName(resultColumnName).equals(DlineageUtil
                                                                                                                        .getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                                                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
                                                                                        && getColumnName(
                                                                                                        columnObject.getExpr().getRightOperand().getObjectOperand())
                                                                                                                        .equals(DlineageUtil.getIdentifierNormalColumnName(
                                                                                                                                        tableColumn.getName()))) {
                                                                                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 (getColumnName(columnName).equals(DlineageUtil
                                                                                                                .getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                                        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 (getColumnName(columnObject.getExpr().getRightOperand().getObjectOperand())
                                                                                        .equals(DlineageUtil
                                                                                                        .getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                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(((TFunctionCall) functionCall).getFunctionName().toString())) {
                        // @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.getFunctionTable(getIdentifiedFunctionName(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();
        }

        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()) {
                                        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);
                                                        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) {
                                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 {
                                                        columnName.setString(getColumnName(resultSet.getColumns().get(i).getName()));
                                                }
                                                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)));
                                        }
                                }
                        }
                }
        }

        private void analyzePrestoUnnest(TSelectSqlStatement stmt, TTable table) {
                List<Table> tables = new ArrayList<Table>();
                TTable targetTable = stmt.getTables().getTable(0);
                Table stmtTable = modelFactory.createTable(targetTable);
                Object sourceTable = null;
                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;
                                }
                        }
                }
                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) {
                        int unnestTableSize = table.getUnnestClause().getColumns().size();
                        for (int i = 0; i < table.getAliasClause().getColumns().size(); i++) {
                                TableColumn sourceColumn = null;
                                if (unnestTableSize > i) {
                                        sourceColumn = modelFactory.createTableColumn(stmtTable,
                                                        table.getUnnestClause().getColumns().getObjectName(i), true);
                                        if (sourceTable instanceof Table) {
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.select);
                                                relation.setTarget(new TableColumnRelationshipElement(sourceColumn));
                                                relation.addSource(
                                                                new TableColumnRelationshipElement(((Table) sourceTable).getColumns().get(i)));
                                        } else if (sourceTable instanceof ResultSet) {
                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                relation.setEffectType(EffectType.select);
                                                relation.setTarget(new TableColumnRelationshipElement(sourceColumn));
                                                relation.addSource(
                                                                new ResultColumnRelationshipElement(((ResultSet) sourceTable).getColumns().get(i)));
                                        }
                                } else {
                                        sourceColumn = modelFactory.createTableColumn(stmtTable,
                                                        table.getUnnestClause().getColumns().getObjectName(unnestTableSize - 1), true);
                                }
                                TableColumn targetColumn = modelFactory.createTableColumn(unnestTable,
                                                table.getAliasClause().getColumns().getObjectName(i), true);
                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.select);
                                relation.setTarget(new TableColumnRelationshipElement(targetColumn));
                                relation.addSource(new TableColumnRelationshipElement(sourceColumn));
                        }
                }

                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 ("*".equals(getColumnName(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;
                                                for (int k = 0; k < tables.size(); k++) {
                                                        Table tableItem = tables.get(k);
                                                        for (TableColumn tableColumn : tableItem.getColumns()) {
                                                                if (getColumnName(columnObject.getFieldAttr())
                                                                                .equals(DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                        match = true;
                                                                }
                                                        }
                                                }
                                                if (!match) {
                                                        TableColumn tableColumn = modelFactory.createTableColumn(stmtTable,
                                                                        columnObject.getFieldAttr(), false);
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.select);
                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                }
                                        }
                                }
                        }
                }
        }

        private void analyzeLateralView(TSelectSqlStatement stmt, TTable table, ArrayList<TLateralView> lateralViews) {
                List<Object> tables = new ArrayList<Object>();
                Object stmtTable = null;
                if(table.getSubquery()!=null) {
                        stmtTable = modelFactory.createQueryTable(table);
                        tables.add(stmtTable);
                }
                else {
                        stmtTable = modelFactory.createTable(table);
                        tables.add(stmtTable);
                }
                for (int i = 0; i < lateralViews.size(); i++) {
                        TLateralView lateralView = lateralViews.get(i);
                        TFunctionCall functionCall = lateralView.getUdtf();
                        List<TExpression> expressions = new ArrayList<TExpression>();
                        if (functionCall == null) {
                                continue;
                        }
                        Function function = modelFactory.createFunction(functionCall);
                        ResultColumn column = modelFactory.createFunctionResultColumn(function,
                                        ((TFunctionCall) functionCall).getFunctionName());

                        Table lateralTable = null;
                        if (lateralView.getTableAlias() != null) {
                                lateralTable = modelFactory.createTableByName(lateralView.getTableAlias().getAliasName(), true);
                        } else {
                                lateralTable = modelFactory.createTableByName(functionCall.toString(), true);
                        }

                        for (int j = 0; j < lateralView.getColumnAliasList().size(); j++) {
                                TObjectName viewColumn = lateralView.getColumnAliasList().getObjectName(j);
                                TableColumn tableColumn = modelFactory.createTableColumn(lateralTable, viewColumn, true);

                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                relation.setEffectType(EffectType.select);
                                relation.setTarget(new TableColumnRelationshipElement(tableColumn));
                                relation.addSource(new ResultColumnRelationshipElement(column));
                        }

                        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) {
                                        boolean match = false;
                                        for (int k = 0; k < tables.size(); k++) {
                                                Object item = tables.get(k);
                                                if(item instanceof Table) {
                                                        Table tableItem = (Table)item;
                                                        for (TableColumn tableColumn : tableItem.getColumns()) {
                                                                if (getColumnName(columnName)
                                                                                .equals(DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                        match = true;
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(column));
                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                }
                                                        }
                                                }
                                                else {
                                                        ResultSet tableItem = (ResultSet)item;
                                                        for (ResultColumn tableColumn : tableItem.getColumns()) {
                                                                if (getColumnName(columnName)
                                                                                .equals(DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                        match = true;
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(column));
                                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                }
                                                        }
                                                }
                                        }
                                        if (!match) {
                                                if(stmtTable instanceof Table) {
                                                        TableColumn tableColumn = modelFactory.createTableColumn((Table)stmtTable, columnName, false);
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.select);
                                                        relation.setTarget(new ResultColumnRelationshipElement(column));
                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                }
                                                else {
                                                        ResultColumn tableColumn = modelFactory.createResultColumn((ResultSet)stmtTable, columnName, false);
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.select);
                                                        relation.setTarget(new ResultColumnRelationshipElement(column));
                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                }
                                        }
                                }
                                List<TParseTreeNode> constants = visitor.getConstants();
                                if (!constants.isEmpty()) {
                                        if (option.isShowConstantTable()) {
                                                Table constantTable = modelFactory.createConstantsTable(stmtStack.peek());
                                                for (TParseTreeNode constant : constants) {
                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                        relation.setEffectType(EffectType.select);
                                                        relation.setTarget(new ResultColumnRelationshipElement(column));
                                                        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);
                                                                relation.addSource(new ConstantRelationshipElement(constantColumn));
                                                        }
                                                }
                                        }
                                }
                                
                                List<TParseTreeNode> functions = visitor.getFunctions();
                                if (functions != null && !functions.isEmpty()) {
                                        analyzeFunctionDataFlowRelation(column, functions, EffectType.function);
                                }
                        }
                        tables.add(lateralTable);
                }

                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 ("*".equals(getColumnName(columnObject.getFieldAttr()))) {
                                                for (int k = 0; k < tables.size(); k++) {
                                                        Object item = tables.get(k);
                                                        if(item instanceof Table) {
                                                                Table tableItem = (Table)item;
                                                                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 {
                                                                ResultSet tableItem = (ResultSet)item;
                                                                for (ResultColumn tableColumn : tableItem.getColumns()) {
                                                                        TObjectName linkColumn = new TObjectName();
                                                                        linkColumn.setString(tableColumn.getName());
                                                                        resultColumn.bindStarLinkColumn(linkColumn);
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn, linkColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                }
                                                        }
                                                }
                                        } else {
                                                boolean match = false;
                                                for (int k = 0; k < tables.size(); k++) {
                                                        Object item = tables.get(k);
                                                        if(item instanceof Table) {
                                                                Table tableItem = (Table)item;
                                                                for (TableColumn tableColumn : tableItem.getColumns()) {
                                                                        if (getColumnName(columnObject.getFieldAttr())
                                                                                        .equals(DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                                match = true;
                                                                        }
                                                                }
                                                        }
                                                        else {
                                                                ResultSet tableItem = (ResultSet)item;
                                                                for (ResultColumn tableColumn : tableItem.getColumns()) {
                                                                        if (getColumnName(columnObject.getFieldAttr())
                                                                                        .equals(DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                                relation.setEffectType(EffectType.select);
                                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                                match = true;
                                                                        }
                                                                }
                                                        }
                                                }
                                                if (!match) {
                                                        if(stmtTable instanceof Table) {
                                                                TableColumn tableColumn = modelFactory.createTableColumn((Table)stmtTable,
                                                                                columnObject.getFieldAttr(), false);
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                        }
                                                        else {
                                                                ResultColumn tableColumn = modelFactory.createResultColumn((ResultSet)stmtTable,
                                                                                columnObject.getFieldAttr(), false);
                                                                DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                relation.setEffectType(EffectType.select);
                                                                relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                        }
                                                }
                                        }
                                }
                                else if (columnObject.getExpr() != null
                                                && columnObject.getExpr().getExpressionType() == EExpressionType.function_t) {
                                        analyzeResultColumn(column, EffectType.select);
                                        for (int k = 0; k < tables.size(); k++) {
                                                Object item = tables.get(k);
                                                if (item instanceof Table) {
                                                        Table tableItem = (Table) item;
                                                        for (TableColumn tableColumn : tableItem.getColumns()) {
                                                                if (getColumnName(resultColumn.getName()).equals(
                                                                                DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.addSource(new TableColumnRelationshipElement(tableColumn));
                                                                }
                                                        }
                                                } else {
                                                        ResultSet tableItem = (ResultSet) item;
                                                        for (ResultColumn tableColumn : tableItem.getColumns()) {
                                                                if (getColumnName(resultColumn.getName()).equals(
                                                                                DlineageUtil.getIdentifierNormalColumnName(tableColumn.getName()))) {
                                                                        DataFlowRelationship relation = modelFactory.createDataFlowRelation();
                                                                        relation.setEffectType(EffectType.select);
                                                                        relation.setTarget(new ResultColumnRelationshipElement(resultColumn));
                                                                        relation.addSource(new ResultColumnRelationshipElement(tableColumn));
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        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) {
                                String functionName = DlineageUtil.getIdentifierNormalTableName(
                                                DlineageUtil.getFunctionNameWithArgNum((TFunctionCall) functionCall));
                                Procedure procedure = modelManager.getProcedureByName(functionName);
                                if (procedure != null) {
                                        String procedureParent = getProcedureParentName(stmtStack.peek());
                                        if (procedureParent != null) {
                                                Procedure caller = modelManager
                                                                .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                                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.getProcedureByName(
                                                DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(call)));
                                if (callee == null && procedureDDLMap.containsKey(DlineageUtil.getFunctionNameWithArgNum(call))) {
                                        analyzeCustomSqlStmt(procedureDDLMap.get(DlineageUtil.getFunctionNameWithArgNum(call)));
                                        callee = modelManager.getProcedureByName(
                                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(call)));
                                }

                                if (callee != null) {
                                        String procedureParent = getProcedureParentName(stmtStack.peek());
                                        if (procedureParent != null) {
                                                Procedure caller = modelManager
                                                                .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                                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.getFunctionTable(DlineageUtil
                                                        .getIdentifierNormalTableName(call.getFunctionName().toString()));
                                        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()));
                                        }
                                }
                        }
                }

        }

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

                if (!isBuiltInFunctionName(functionObj.getFunctionName())) {
                    TCustomSqlStatement stmt = stmtStack.peek();
                    String procedureParent = getProcedureParentName(stmt);
                    if (procedureParent != null) {
                        Procedure procedureCallee = modelManager.getProcedureByName(DlineageUtil
                                .getIdentifierNormalTableName(DlineageUtil.getFunctionNameWithArgNum(functionObj)));
                        if (procedureCallee != null) {
                            if (procedureParent != null) {
                                Procedure caller = modelManager
                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                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();
                            if (functionName.indexOf(".") != -1) {
                                Table functionTable = modelManager
                                        .getTableByName(functionName.substring(0, functionName.indexOf(".")));
                                if (functionTable != null) {
                                    String columnName = functionName.substring(functionName.indexOf(".") + 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 = modelManager
                                        .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureParent));
                                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);
                                if (resultColumn.getAliasClause() != null) {
                                    ResultColumn column = modelFactory.createFunctionResultColumn(function,
                                            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(((TFunctionCall) functionCall).getFunctionName().toString())) {
                    // @see https://e.gitee.com/gudusoft/issues/list?issue=I40NUP
                    // COUNT特殊处理，不和参数关联
                    if (option.isShowCountTableColumn()) {
                        analyzeFunctionArgumentsDataFlowRelation(column, functionCall);
                    }
                } else {
                    boolean isCustomFunction = analyzeCustomFunctionCall((TFunctionCall) functionCall);
//                              if(!isCustomFunction) 
                    {
                        analyzeFunctionArgumentsDataFlowRelation(column, functionCall);
                    }
                    Set<Object> functionTableModelObjs = modelManager.getFunctionTable(getIdentifiedFunctionName(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);
        }
    }

        protected String getIdentifiedFunctionName(Function function) {
                return DlineageUtil.getIdentifierNormalFunctionName(function.getFunctionName());
        }
        
        private boolean isConstantFunction(TObjectName functionName) {
                boolean result = CONSTANT_BUILTIN_FUNCTIONS.contains(functionName.toString().toUpperCase());
                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();
                        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, 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();

                // 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) {
                                        e.getObjectOperand().setSourceTable(fallbackTable);
                                }
                                direct.add(e);
                        }
                }
        }

        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 = DlineageUtil.getColumnName(expr.getObjectOperand());
                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 = new TObjectName();
                starName.setString("*");
                ResultColumn starColumn = modelFactory.createFunctionResultColumn(function, starName);
                starColumn.setStruct(true);
                starColumn.setShowStar(true);

                if (tableModel instanceof Table) {
                        Table sourceTable = (Table) tableModel;
                        TableColumn sourceCol = findOrCreateTableColumn(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 = findOrCreateResultColumn(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()) {
                        String pathDisplay = fb.getSourcePath().toDisplayString();
                        TableColumn pathColumn = findOrCreateStructuredPathColumn(sourceTable, pathDisplay);
                        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
         * standard {@link #findOrCreateTableColumn(Table, String)}, 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, String pathDisplay) {
                if (table == null || pathDisplay == null || pathDisplay.isEmpty()) return null;
                for (TableColumn tc : table.getColumns()) {
                        if (pathDisplay.equalsIgnoreCase(tc.getName())) {
                                return tc;
                        }
                }
                return new TableColumn(table, pathDisplay);
        }

        private TableColumn findOrCreateTableColumn(Table table, String colName) {
                String normalName = DlineageUtil.getIdentifierNormalColumnName(colName);
                for (TableColumn tc : table.getColumns()) {
                        if ("*".equals(colName) && "*".equals(tc.getName())) return tc;
                        if (DlineageUtil.compareColumnIdentifier(tc.getName(), normalName)) return tc;
                }
                TObjectName obj = new TObjectName();
                obj.setString(colName);
                return modelFactory.createTableColumn(table, obj, "*".equals(colName));
        }

        private ResultColumn findOrCreateResultColumn(ResultSet resultSet, String colName) {
                String normalName = DlineageUtil.getIdentifierNormalColumnName(colName);
                for (ResultColumn rc : resultSet.getColumns()) {
                        if ("*".equals(colName) && "*".equals(rc.getName())) return rc;
                        if (DlineageUtil.compareColumnIdentifier(rc.getName(), normalName)) return rc;
                }
                TObjectName obj = new TObjectName();
                obj.setString(colName);
                return modelFactory.createResultColumn(resultSet, obj);
        }

        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);
                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());
                }
//              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 = new TObjectName();
                                        columnName.setString(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);
                                }
                                resultSet.setDetermined(true);
                                return;
                        }
                        
                        boolean isDetermined = true;
                        for (int i = 0; i < columnList.size(); i++) {
                                TResultColumn column = columnList.getResultColumn(i);
                                
                                if ("*".equals(column.getColumnNameOnly())) {
                                        TObjectName columnObject = column.getFieldAttr();
                                        TTable sourceTable = columnObject.getSourceTable();
                                        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 (getColumnName(objectName.toString())
                                                                                                .equals(getColumnName(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 (getColumnName(objectName.toString())
                                                                                                                .equals(getColumnName(name))) {
                                                                                                        except = true;
                                                                                                        break;
                                                                                                }
                                                                                        }
                                                                                        if (except) {
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                        if (except) {
                                                                                continue;
                                                                        }
                                                                }
                                                                TObjectName columnName = new TObjectName();
                                                                columnName.setString(tableColumn.getName());
                                                                ResultColumn resultColumn = modelFactory.createResultColumn(
                                                                                resultSet, columnName);
                                                                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 (getColumnName(objectName.toString())
                                                                                                .equals(getColumnName(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 (getColumnName(objectName.toString())
                                                                                                                .equals(getColumnName(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);
                                                                        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);
                                                                        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 ("*".equals(getColumnName(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 ("*".equals(getColumnName(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 ("*".equals(
                                                                                                        getColumnName(tableModel.getColumns().get(z).getColumnObject()))) {
                                                                                                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 ("*".equals(getColumnName(starLinkColumn))) {
                                                                                                                continue;
                                                                                                        }
                                                                                                        resultColumn.bindStarLinkColumn(starLinkColumn);
                                                                                                }
                                                                                        } else if (item.getColumnObject() instanceof TObjectName) {
                                                                                                TObjectName starLinkColumn = (TObjectName) item.getColumnObject();
                                                                                                if ("*".equals(getColumnName(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 ("*".equals(getColumnName(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);
                }
        }
        
        
        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()) {
                                        columnsInExpr visitor = new columnsInExpr();
                                        expr.inOrderTraverse(visitor);
                                        List<TObjectName> objectNames = visitor.getObjectNames();
                                        analyzeDataFlowRelation(object, objectNames, column.getExceptColumnList(), effectType, null, null);
                                        List<TParseTreeNode> constants = visitor.getConstants();
                                        analyzeConstantDataFlowRelation(object, constants, effectType, null);
                                }
                        }
                        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 {
                        columnsInExpr visitor = new columnsInExpr();
                        expression.inOrderTraverse(visitor);
                        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) {
                // 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) {
                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 (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);
        }
        
        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) {
                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 ("*".equals(((ResultColumn) modelObject).getName())) {
                                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 ("*".equals(((TableColumn) modelObject).getName())) {
                                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).

                for (int i = 0; i < objectNames.size(); i++) {
                        TObjectName columnName = objectNames.get(i);
                        if (columnName.toString().indexOf(".") == -1 && isConstant(columnName)) {
                                boolean isConstant = true;
                                if (columnName.getSourceTable() != null) {
                                        Table tableModel = modelManager.getTableByName(
                                                        DlineageUtil.getTableFullName(columnName.getSourceTable().getTableName().toString()));
                                        if (tableModel != null && tableModel.getColumns() != null) {
                                                for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                        if (DlineageUtil.compareColumnIdentifier(getColumnName(columnName),
                                                                        getColumnName(tableModel.getColumns().get(j).getName()))) {
                                                                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.getTableByName(DlineageUtil.getTableFullName(columnName.toString()));
                                        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 = modelManager
                                                                        .getProcedureByName(DlineageUtil.getTableFullName(getProcedureParentName(stmt)));
                                                        if(procedure!=null) {
                                                                Variable cursorVariable = modelFactory.createVariable(procedure.getArguments().get(Integer.valueOf(columnName.toString().replace("$", "")) - 1).getName());
                                                                if (isOut) {
                                                                        relation.setTarget(new TableColumnRelationshipElement(cursorVariable.getColumns().get(0)));
                                                                } else {
                                                                        relation.addSource(new TableColumnRelationshipElement(cursorVariable.getColumns().get(0)));
                                                                }
                                                        }
                                                } else {
                                                        Variable cursorVariable = modelFactory.createVariable(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
                                                        .createVariable(columnName.getTableToken().toString());

                                        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 (getColumnName(variableColumnName)
                                                                        .equals(getColumnName(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
                                                        .getTableByName(DlineageUtil.getTableFullName(segments.get(segments.size() - 2)));
                                        if (variable != null) {
                                                for (int j = 0; j < variable.getColumns().size(); j++) {
                                                        if (getColumnName(columnName)
                                                                        .equals(getColumnName(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 = modelManager
                                                                .getProcedureByName(DlineageUtil.getTableFullName(getProcedureParentName(stmt)));
                                                if (procedure != null && procedure.getArguments() != null) {
                                                        for (Argument argument : procedure.getArguments()) {
                                                                if (DlineageUtil.getTableFullName(argument.getName())
                                                                                .equals(DlineageUtil.getTableFullName(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.getTableByName(DlineageUtil.getTableFullName(columnName.toString()));
                                        if (variable == null) {
                                                variable = modelManager
                                                                .getTableByName(DlineageUtil.getTableFullName(columnName.getTableString()));
                                                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)) {
                                Table variable = modelManager
                                                .getTableByName(DlineageUtil.getTableFullName(columnName.getColumnNameOnly().replace(":", "")));
                                if (variable != null) {
                                        for (int j = 0; j < variable.getColumns().size(); j++) {
                                                if (getColumnName(columnName).replace(":", "")
                                                                .equals(getColumnName(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) {
                                                tableModel = modelManager
                                                                .getTableByName(DlineageUtil.getTableFullName(columnName.getTableToken().toString()));
                                        }

                                        if (tableModel == null) {
                                                TCustomSqlStatement currentStmt = ModelBindingManager.getGlobalStmtStack().peek();
                                                String procedureName = DlineageUtil.getProcedureParentName(currentStmt);
                                                String variableString = columnName.getTableToken().toString();
                                                if (variableString.startsWith(":")) {
                                                        variableString = variableString.substring(variableString.indexOf(":") + 1);
                                                }
                                                if (!SQLUtil.isEmpty(procedureName)) {
                                                        variableString = procedureName + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                                                }

                                                if (modelManager
                                                                .getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
                                                        tableModel = modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
                                                }
                                        }

                                        if (tableModel != null) {

                                                if (table == null) {
                                                        table = tableModel.getTableObject();
                                                }

                                                if (tableModel.isVariable()) {
                                                        if (!isStar && "*".equals(getColumnName(columnName))) {
                                                                TObjectName[] columns = modelManager.getTableColumns(table);
                                                                for (int j = 0; j < columns.length; j++) {
                                                                        TObjectName objectName = columns[j];
                                                                        if (objectName == null || "*".equals(getColumnName(objectName))) {
                                                                                continue;
                                                                        }
                                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel, objectName,
                                                                                        false);
                                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                }
                                                        } else {
                                                                if ("*".equals(getColumnName(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 (getColumnName(objectName)
                                                                                                                .equals(getColumnName(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(!"*".equals(getColumnName(columnName))){
                                                                                                columnModel.bindStarLinkColumn(columnName);
                                                                                        }
                                                                                }
                                                                        }
                                                                        
                                                                        if (columnModel == null) {
                                                                                continue;
                                                                        }
                                                                        if (columnModel.hasStarLinkColumn()) {
                                                                                relation.addSource(new TableColumnRelationshipElement(columnModel,
                                                                                                columnModel.getStarLinkColumnNames()
                                                                                                                .indexOf(DlineageUtil.getColumnName(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 || !"*".equals(getColumnName(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 ("*".equals(getColumnName(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.getIdentifierNormalColumnName(getColumnName(refer))
                                                                                                .equals(DlineageUtil.getIdentifierNormalColumnName(baseName))) {
                                                                                        table = tTable;
                                                                                        break;
                                                                                }
                                                                        }
                                                                        if (getColumnName(refer).equals(getColumnName(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 ("*".equals(getColumnName(refer)))
                                                                                continue;
                                                                        if (getColumnName(refer).equals(getColumnName(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;
                                                                for (int z = 0; tableModel.getColumns() != null
                                                                                && z < tableModel.getColumns().size(); z++) {
                                                                        TableColumn refer = tableModel.getColumns().get(z);
                                                                        if (getColumnName(refer.getName()).equals(getColumnName(columnName))) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                        if (refer.hasStarLinkColumn()) {
                                                                                for (TObjectName linkColumn : refer.getStarLinkColumnList()) {
                                                                                        if (getColumnName(linkColumn).equals(getColumnName(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.getIdentifierNormalColumnName(refer.getName())
                                                                                                .equals(DlineageUtil.getIdentifierNormalColumnName(baseName))) {
                                                                                        table = tTable;
                                                                                        break;
                                                                                }
                                                                        }
                                                                        List<String> splits = SQLUtil.parseNames(columnName.toString());
                                                                        if (splits.size() > 1 && EDbVendor.dbvbigquery == getOption().getVendor()) {
                                                                                if (DlineageUtil.getIdentifierNormalColumnName(refer.getName())
                                                                                                .equals(DlineageUtil
                                                                                                                .getIdentifierNormalColumnName(getColumnName(splits.get(0))))) {
                                                                                        table = tTable;
                                                                                        break;
                                                                                }
                                                                        }
                                                                        else if (DlineageUtil.getIdentifierNormalColumnName(refer.getName()).equals(
                                                                                        DlineageUtil.getIdentifierNormalColumnName(getColumnName(columnName)))) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                        if (refer.hasStarLinkColumn()) {
                                                                                for (TObjectName linkColumn : refer.getStarLinkColumnList()) {
                                                                                        if (getColumnName(linkColumn).equals(getColumnName(columnName))) {
                                                                                                table = tTable;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }

                                if (columnName.getTableToken() == null && "*".equals(getColumnName(columnName))) {
                                        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.getTableFullName(columnName.getSourceTable().getTableName().toString()));
                                                if (tableModel != null && tableModel.getColumns() != null) {
                                                        for (int j = 0; j < tableModel.getColumns().size(); j++) {
                                                                if (DlineageUtil.compareColumnIdentifier(getColumnName(columnName),
                                                                                getColumnName(tableModel.getColumns().get(j).getName()))) {
                                                                        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 (getColumnName(columnName).equals(getColumnName(resultColumn.getName()))) {
                                                                        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) {
                                                if (isOut) {
                                                        relation.setTarget(new TableColumnRelationshipElement(pseudoTableColumn));
                                                } else {
                                                        relation.addSource(new TableColumnRelationshipElement(pseudoTableColumn));
                                                }
                                        }

                                        if (isLinkOrphanColumnToFirstTable()) {
                                                TTable orphanTable = tableList.getTable(0);
                                                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 (subquery.getResultColumnList().toString().endsWith("*") && 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 (subquery.getResultColumnList().toString().endsWith("*") && 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 && "*".equals(getColumnName(columnName))) {
                                                                TObjectName[] columns = modelManager.getTableColumns(table);
                                                                for (int j = 0; j < columns.length; j++) {
                                                                        TObjectName objectName = columns[j];
                                                                        if (objectName == null || ("*".equals(getColumnName(objectName)) && tableModel.isDetermined())) {
                                                                                continue;
                                                                        }
                                                                        TableColumn columnModel = modelFactory.createTableColumn(tableModel, objectName,
                                                                                        false);
                                                                        if(columnModel == null) {
                                                                                continue;
                                                                        }
                                                                        relation.addSource(new TableColumnRelationshipElement(columnModel));
                                                                }
                                                        } else {
                                                                if ("*".equals(getColumnName(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 (getColumnName(objectName)
                                                                                                                .equals(getColumnName(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.getIdentifierNormalColumnName(tableColumn.getName())
                                                                                                                        .equals(DlineageUtil.getIdentifierNormalColumnName(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 (!getColumnName(targetNames.get(0))
                                                                                                                                                .equals(getColumnName(names.get(0)))) {
                                                                                                                                        continue;
                                                                                                                                }
                                                                                                                        }
                                                                                                                }
                                                                                                                else if (modelObject instanceof ResultColumn) {
                                                                                                                        ResultColumn targetColumn = (ResultColumn) modelObject;
                                                                                                                        if (targetColumn.isStruct()) {
                                                                                                                                List<String> targetNames = SQLUtil
                                                                                                                                                .parseNames(targetColumn.getName());
                                                                                                                                if (!getColumnName(targetNames.get(0))
                                                                                                                                                .equals(getColumnName(names.get(0)))) {
                                                                                                                                        continue;
                                                                                                                                }
                                                                                                                        }
                                                                                                                }
                                                                                                                for(String name: names) {
                                                                                                                        if (getColumnName(name)
                                                                                                                                        .equals(getColumnName(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;
                                                                                                                        }
                                                                                                                }

                                                                                                                if (!flag && tableModel.getColumns().size() == 1 && tableModel
                                                                                                                                .getColumns().get(0).getSourceColumn() != null) {
                                                                                                                        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 (getColumnName(tableColumn.getName())
                                                                                                                        .equals(getColumnName(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()
                                                                                                                                .indexOf(column.getName().toLowerCase()) == -1
                                                                                                                                && tableColumn.getName().toLowerCase()
                                                                                                                                                .indexOf(column.getColumnObject().toString()
                                                                                                                                                                .toLowerCase()) == -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()
                                                                                                                                .indexOf(column.getName().toLowerCase()) == -1
                                                                                                                                && tableColumn.getName().toLowerCase()
                                                                                                                                                .indexOf(column.getColumnObject().toString()
                                                                                                                                                                .toLowerCase()) == -1) {
                                                                                                                        continue;
                                                                                                                }
                                                                                                                flag = true;
                                                                                                                relation.addSource(
                                                                                                                                new TableColumnRelationshipElement(tableColumn));
                                                                                                                relation.setShowStarRelation(true);
                                                                                                        }
                                                                                                        if (flag)
                                                                                                                break;

                                                                                                }
                                                                                        }
                                                                                        if (!flag 
                                                                                                        && (isStar 
                                                                                                                        || getColumnName(columnName).equals(getColumnName(tableModel.getName()))
                                                                                                                        || getColumnName(columnName).equals(getColumnName(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 (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 (getColumnName(columnName).equals("*")) {
                                                                        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 (getColumnName(objectName)
                                                                                                                                .equals(getColumnName(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.getStarLinkColumns().isEmpty()) {
                                                                                                if (cteColumns != null) {
                                                                                                        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 (getColumnName(linkColumn).equals(getColumnName(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) {
                                                                                                                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 (getColumnName(columnName).equals("*")) {
                                                                        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 (getColumnName(objectName)
                                                                                                                .equals(getColumnName(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 (getColumnName(columnName).equals("*")) {
                                                                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 (getColumnName(objectName)
                                                                                                        .equals(getColumnName(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 (getColumnName(name).equals(getColumnName(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 (getColumnName(name)
                                                                                                                                        .equals(getColumnName(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.byNormalizedName != 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.byNormalizedName.get(getColumnName(columnName));
                                                                                if (match != null && !match.equals(modelObject)) {
                                                                                        relation.addSource(
                                                                                                        new ResultColumnRelationshipElement(match, columnName));
                                                                                }
                                                                        } else {
                                                                        String targetColName = getColumnName(columnName); // loop-invariant, hoisted
                                                                        for (k = 0; k < columns.size(); k++) {
                                                                                ResultColumn column = columns.get(k);
                                                                                if ("*".equals(column.getName())) {
                                                                                        if (!containsStarColumn(column, columnName)) {
                                                                                                column.bindStarLinkColumn(columnName);
                                                                                        }
                                                                                        relation.addSource(new ResultColumnRelationshipElement(column, columnName));
                                                                                } else if (DlineageUtil.compareColumnIdentifier(targetColName,
                                                                                                DlineageUtil.getIdentifierNormalColumnName(column.getName()))) {
                                                                                        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 (getColumnName(name)
                                                                                                                .equals(getColumnName(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 (getColumnName(name)
                                                                                                                        .equals(getColumnName(column.getName()))) {
                                                                                                                relation.addSource(
                                                                                                                                new ResultColumnRelationshipElement(column, columnName));
                                                                                                        }
                                                                                                }
                                                                                        }
                                                                                }
                                                                        }
                                                                        }
                                                                } else if (table.getAliasClause() != null
                                                                                && table.getAliasClause().getColumns() != null) {
                                                                        for (k = 0; k < columns.size(); k++) {
                                                                                ResultColumn column = columns.get(k);
                                                                                List<String> splits = SQLUtil.parseNames(columnName.toString());        
                                                                                if ("*".equals(column.getName())) {
                                                                                        if (!containsStarColumn(column, columnName)) {
                                                                                                column.bindStarLinkColumn(columnName);
                                                                                        }
                                                                                        relation.addSource(new ResultColumnRelationshipElement(column, columnName));
                                                                                } else if (splits.size() > 1 && EDbVendor.dbvbigquery == getOption().getVendor()) {
                                                                                        if (DlineageUtil.compareColumnIdentifier(getColumnName(splits.get(0)),
                                                                                                        DlineageUtil.getIdentifierNormalColumnName(column.getName()))) {
                                                                                                if (!column.equals(modelObject)) {
                                                                                                        relation.addSource(new ResultColumnRelationshipElement(column,
                                                                                                                        columnName));
                                                                                                }
                                                                                                break;
                                                                                        }
                                                                                } else if (DlineageUtil.compareColumnIdentifier(getColumnName(columnName),
                                                                                                DlineageUtil.getIdentifierNormalColumnName(column.getName()))) {
                                                                                        if (!column.equals(modelObject)) {
                                                                                                relation.addSource(
                                                                                                                new ResultColumnRelationshipElement(column, columnName));
                                                                                        }
                                                                                        break;
                                                                                }
                                                                        }
                                                                } 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 ("*".equals(column.getName())) {
                                                                                                if (!containsStarColumn(column, columnName)) {
                                                                                                        column.bindStarLinkColumn(columnName);
                                                                                                }
                                                                                                relation.addSource(new ResultColumnRelationshipElement(column, columnName));
                                                                                        } else if (splits.size() > 1 && EDbVendor.dbvbigquery == getOption().getVendor()) {
                                                                                                if (DlineageUtil.compareColumnIdentifier(getColumnName(splits.get(0)),
                                                                                                                DlineageUtil.getIdentifierNormalColumnName(column.getName()))) {
                                                                                                        if (!column.equals(modelObject)) {
                                                                                                                relation.addSource(new ResultColumnRelationshipElement(column,
                                                                                                                                columnName));
                                                                                                        }
                                                                                                        break;
                                                                                                }
                                                                                        } else if (DlineageUtil.compareColumnIdentifier(getColumnName(columnName),
                                                                                                        DlineageUtil.getIdentifierNormalColumnName(column.getName()))) {
                                                                                                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 ("*".equals(resultColumn.getName())
                                                                                                        && !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));
                        }

                        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);
                                        }
                                }
                        }
                }
                return relation;
        }

        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 (DlineageUtil.compareColumnIdentifier(getColumnName(columnName),
                                                DlineageUtil.getIdentifierNormalColumnName(column.getName()))) {
                                        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 ("*".equals(column.getName())) {
                                                if (!containsStarColumn(column, columnName)) {
                                                        column.bindStarLinkColumn(columnName);
                                                }
                                                relation.addSource(new ResultColumnRelationshipElement(column, columnName));
                                                flag = true;
                                                break;
                                        }
                                }
                        }
                        if (!flag && columnIndex < queryColumns.size() && columnIndex != -1) {
                                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) {
                String targetColumnName = getColumnName(columnName);
                if (resultColumn.hasStarLinkColumn()) {
                        return resultColumn.getStarLinkColumns().containsKey(targetColumnName);
                }
                return false;
        }

        private void analyzeAggregate(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();
                        for (int j = 0; j < objectNames.size(); j++) {
                                TObjectName columnName = objectNames.get(j);

                                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 = modelManager.getTable(stmt, columnName);
                                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) {
                                                        ResultColumn resultColumn = (ResultColumn) model;
                                                        if (resultColumn != null) {
                                                                relation.addSource(
                                                                                new ResultColumnRelationshipElement(resultColumn, columnName.getLocation(), columnName));
                                                        }
                                                }
                                        }
                                }
                        }

                        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(function.getFunctionName().toString())) {
                                                // 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(function.getFunctionName().toString())) {
                                                // 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(function.getFunctionName().toString())) {
                        if ("COUNT".equalsIgnoreCase(function.getFunctionName().toString())
                                        // 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(function.getFunctionName().toString())) {
                                                                // 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(function.getFunctionName().toString())) {
                                                                // 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);
                                                }
                                        }
                                }
                        }

                        if (stmt.getWhereClause() == null || stmt.getWhereClause().getCondition() == null) {
                                return;
                        }

                        columnsInExpr visitor = new columnsInExpr();
                        stmt.getWhereClause().getCondition().inOrderTraverse(visitor);
                        List<TObjectName> objectNames = visitor.getObjectNames();
                        for (int j = 0; j < objectNames.size(); j++) {
                                TObjectName columnName = objectNames.get(j);
                                if (columnName.getDbObjectType() == EDbObjectType.variable) {
                                        Variable tableModel;
                                        if (columnName.toString().indexOf(".") != -1) {
                                                List<String> splits = SQLUtil.parseNames(columnName.toString());
                                                tableModel = modelFactory.createVariable(splits.get(splits.size() - 2));
                                        } else {
                                                tableModel = modelFactory.createVariable(columnName);
                                        }
                                        tableModel.setCreateTable(true);
                                        tableModel.setSubType(SubType.record);
                                        TObjectName variableProperties = new TObjectName();
                                        variableProperties.setString("*");
                                        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 = modelManager.getTable(stmt, columnName);
                                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) {
                                                        ResultColumn resultColumn = (ResultColumn) model;
                                                        if (resultColumn != null) {
                                                                relation.addSource(
                                                                                new ResultColumnRelationshipElement(resultColumn, columnName.getLocation(), columnName));
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        private void analyzeFilterCondition(Object modelObject, TExpression expr, EJoinType joinType,
                        JoinClauseType joinClauseType, EffectType effectType) {
                if (expr == null) {
                        return;
                }

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

                        for (int j = 0; j < objectNames.size(); j++) {
                                TObjectName columnName = objectNames.get(j);
                                if (columnName.getDbObjectType() == EDbObjectType.variable) {
                                        Variable variable = modelFactory.createVariable(columnName);
                                        variable.setSubType(SubType.record);
                                        if (variable.getColumns().isEmpty()) {
                                                TObjectName variableProperties = new TObjectName();
                                                variableProperties.setString("*");
                                                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 ("*".equals(getColumnName(refer)))
                                                                        continue;
                                                                if (getColumnName(refer).equals(getColumnName(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 (getColumnName(refer.getName()).equals(getColumnName(columnName))) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                        if (refer.hasStarLinkColumn()) {
                                                                                for (TObjectName linkColumn : refer.getStarLinkColumnList()) {
                                                                                        if (getColumnName(linkColumn).equals(getColumnName(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.getIdentifierNormalColumnName(refer.getName()).equals(
                                                                                        DlineageUtil.getIdentifierNormalColumnName(getColumnName(columnName)))) {
                                                                                table = tTable;
                                                                                break;
                                                                        }
                                                                        if (refer.hasStarLinkColumn()) {
                                                                                for (TObjectName linkColumn : refer.getStarLinkColumnList()) {
                                                                                        if (getColumnName(linkColumn).equals(getColumnName(columnName))) {
                                                                                                table = tTable;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }

                                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 (getColumnName(columnName).equals(getColumnName(resultColumn.getName()))) {
                                                                        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) {
                                                relation.addSource(new TableColumnRelationshipElement(pseudoTableColumn));
                                        }

                                        if (isLinkOrphanColumnToFirstTable()) {
                                                TTable orphanTable = stmt.tables.getTable(0);
                                                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);
                                                        }

                                                        for (ResultSet sourceResultSet : resultSets) {
                                                                if (sourceResultSet != null && columnName.getSourceColumn() != null) {
                                                                        for (int k = 0; k < sourceResultSet.getColumns().size(); k++) {
                                                                                if (getColumnName(sourceResultSet.getColumns().get(k).getName()).equals(
                                                                                                getColumnName(columnName.getSourceColumn().getColumnNameOnly()))) {
                                                                                        Set<TObjectName> starLinkColumnSet = sourceResultSet.getColumns().get(k)
                                                                                                        .getStarLinkColumns().get(getColumnName(columnName));
                                                                                        if (starLinkColumnSet != null && !starLinkColumnSet.isEmpty()) {
                                                                                                ResultColumn column = modelFactory.createResultColumn(sourceResultSet,
                                                                                                                starLinkColumnSet.iterator().next(), 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);
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                } else {
                                                        Object model = modelManager.getModel(columnName.getSourceColumn());
                                                        if (model instanceof ResultColumn) {
                                                                ResultColumn resultColumn = (ResultColumn) model;
                                                                if (resultColumn != null) {
                                                                        if (resultColumn.hasStarLinkColumn()) {
                                                                                Set<TObjectName> starLinkColumnSet = resultColumn.getStarLinkColumns()
                                                                                                .get(getColumnName(columnName));
                                                                                if (starLinkColumnSet != null && !starLinkColumnSet.isEmpty()) {
                                                                                        ResultColumn column = modelFactory.createResultColumn(
                                                                                                        resultColumn.getResultSet(), starLinkColumnSet.iterator().next(), 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;
                                                                for (int i = 0; i < tableModel.getColumns().size(); i++) {
                                                                        ResultColumn resultColumn = tableModel.getColumns().get(i);
                                                                        if (DlineageUtil.getIdentifierNormalColumnName(resultColumn.getName()).equals(
                                                                                        DlineageUtil.getIdentifierNormalColumnName(getColumnName(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.getName().endsWith("*")) {
                                                                                resultColumn.bindStarLinkColumn(columnName);
                                                                        }
                                                                }
                                                                if(!find){
                                                                        ResultColumn resultColumn = new ResultColumn(tableModel, columnName);
                                                                        ResultColumnRelationshipElement element = new ResultColumnRelationshipElement(
                                                                                                resultColumn, columnName.getLocation(), columnName);
                                                                                relation.addSource(element);
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }

                        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,
                                                                        ((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 && ((TFunctionCall) functionObj).getFunctionName()!=null) {
                                        TableColumn tableColumn = modelFactory.createTableColumn((Table) functionModel,
                                                        ((TFunctionCall) functionObj).getFunctionName(), false);
                                        if (tableColumn != null) {
                                                TableColumnRelationshipElement element = new TableColumnRelationshipElement(tableColumn);
                                                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));
                                }
                        }
                }

                if (isShowJoin() && joinClauseType != null) {
                        joinInExpr joinVisitor = new joinInExpr(joinType, joinClauseType, effectType);
                        expr.inOrderTraverse(joinVisitor);
                }
        }

        public void dispose() {
                authoritativeEvidenceCollector.reset();
                cteSelectRelationKeys.clear();
                accessedSubqueries.clear();
                accessedStatements.clear();
                stmtStack.clear();
                viewDDLMap.clear();
                procedureDDLMap.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;

                /**
                 * 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) {
                                        if(lcexpr.getConstantOperand().getInt64_expression()!=null 
                                                        && lcexpr.getConstantOperand().getInt64_expression().getExpressionType() == EExpressionType.function_t) {
                                                lcexpr.getConstantOperand().getInt64_expression().inOrderTraverse(this);
                                        }
                                        else {
                                                constants.add(lcexpr.getConstantOperand());
                                        }
                                }
                        } 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")
                                        // These are function parameter names, NOT column references
                                        if (object.getObjectType() == TObjectName.ttobjNamedArgParameter) {
                                                // Skip - this is a named argument 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);
                                        }
                                }
                        } 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.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 (sqlparser.parse() == 0) {
                                                                TObjectName objectName = sqlparser.sqlstatements.get(0).getResultColumnList()
                                                                                .getResultColumn(0).getFieldAttr();
                                                                objectNames.add(objectName);
                                                        }
                                                }
                                        }
                                }
                        } 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);
                                        }
                                } else {
                                        functions.add(func);
                                }

                        } 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 (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 (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.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(SQLUtil.getIdentifierNormalColumnName(vendor, target.getColumn()));
                                                        targetModel.setParentName(
                                                                        SQLUtil.getIdentifierNormalTableName(vendor, target.getParent_name()));
                                                        targetModel.setTargetName(
                                                                        SQLUtil.getIdentifierNormalColumnName(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(SQLUtil.getIdentifierNormalColumnName(vendor, source.getColumn()));
                                                        sourceModel.setParentName(
                                                                        SQLUtil.getIdentifierNormalTableName(vendor, source.getParent_name()));
                                                        sourceModel.setSourceName(
                                                                        SQLUtil.getIdentifierNormalColumnName(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(
                                                                                        SQLUtil.getIdentifierNormalTableName(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(SQLUtil.getIdentifierNormalColumnName(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(SQLUtil.getIdentifierNormalColumnName(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().indexOf("sqldep") != -1
                                                        || sql.toLowerCase().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().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.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());
                                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());
                                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;
                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(func.getFunctionName().toString().toUpperCase());
        }

        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()) != -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().startsWith("[measures].")
                                                        || withName.toLowerCase().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().startsWith("[measures].")
                                                || name.toLowerCase().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());
        }

}