package gudusoft.gsqlparser.dlineage.dataflow.model;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EExpressionType;
import gudusoft.gsqlparser.ESetOperatorType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.dlineage.util.DlineageUtil;
import gudusoft.gsqlparser.dlineage.util.Pair;
import gudusoft.gsqlparser.dlineage.util.Pair3;
import gudusoft.gsqlparser.dlineage.util.SHA256;
import gudusoft.gsqlparser.nodes.*;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.stmt.*;
import gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare;
import gudusoft.gsqlparser.util.IndexedLinkedHashMap;
import gudusoft.gsqlparser.util.Logger;
import gudusoft.gsqlparser.util.LoggerFactory;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.*;

@SuppressWarnings({ "unchecked", "rawtypes" })
public class ModelBindingManager {

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

        private final Map modelBindingMap = new LinkedHashMap();
        private final Map processModelBindingMap = new LinkedHashMap();
        private final Map viewModelBindingMap = new LinkedHashMap();
        private final Map insertModelBindingMap = new LinkedHashMap();
        private final Map createModelBindingMap = new LinkedHashMap();
        private final Map createModelQuickBindingMap = new LinkedHashMap();
        private final Map mergeModelBindingMap = new LinkedHashMap();
        private final Map updateModelBindingMap = new LinkedHashMap();
        private final Map cursorModelBindingMap = new LinkedHashMap();
        private final Map functionTableMap = new LinkedHashMap<>();
        private final Map tableNamesMap = new LinkedHashMap();
        private final Set<Table> dropTables = new HashSet<Table>();
        private final Map procedureNamesMap = new LinkedHashMap();
        private final Map oraclePackageNamesMap = new LinkedHashMap();
        private final Set<Relationship> relationHolder = Collections.synchronizedSet(new LinkedHashSet<Relationship>());
        private final Map<String, TTable> tableAliasMap = new LinkedHashMap();
        private final Map<TCustomSqlStatement, String> tableHashMap = new LinkedHashMap();
        private final Map<TCustomSqlStatement, String> topStmtHashMap = new HashMap();
        private final Map hashSQLMap = new HashMap();
        private final Map dynamicSQLMap = new HashMap();
        private final Set tableSet = new LinkedHashSet();
        private final Set resultSetSet = new LinkedHashSet();
        private final Set<String> dblinkTableSet = new LinkedHashSet();

        // Pipelined function stitching state
        private final Map<String, List<String>> objectTypeIndex = new LinkedHashMap<>();
        private final Map<String, String> collectionToElementTypeIndex = new LinkedHashMap<>();
        private final Map<String, List<PipelinedFunctionSignature>> pipelinedSignatures = new LinkedHashMap<>();
        private final List<PendingPipelinedCallSite> pendingPipelinedCallSites = new ArrayList<>();
        private final Set<String> resolvingPipelinedFunctions = new HashSet<>();

        public Map<String, Long> DISPLAY_ID = new LinkedHashMap<String, Long>();
        public Map<Long, String> DISPLAY_NAME = new LinkedHashMap<Long, String>();
        public Map<String, String> virtualTableNames = new LinkedHashMap<String, String>();

        public long TABLE_COLUMN_ID = 0;
        public long RELATION_ID = 0;
        public int virtualTableIndex = -1;

        private final static ThreadLocal localManager = new ThreadLocal();
        private final static ThreadLocal globalDatabase = new ThreadLocal();
        private final static ThreadLocal globalSchema = new ThreadLocal();
        private final static ThreadLocal globalVendor = new ThreadLocal();
        private final static ThreadLocal globalSQLEnv = new ThreadLocal();
        private final static ThreadLocal globalHash = new ThreadLocal();
        private final static ThreadLocal globalStmtStack = new ThreadLocal();
        private final static ThreadLocal globalSqlInfo = new ThreadLocal();
        private final static ThreadLocal globalOption = new ThreadLocal();
        private final static ThreadLocal globalOraclePackage = new ThreadLocal();
        private final static ThreadLocal globalProcedure = new ThreadLocal();

        public static void set(ModelBindingManager modelManager) {
                if (modelManager != null) {
                        localManager.set(modelManager);
                }
        }

        public static ModelBindingManager get() {
                return (ModelBindingManager) localManager.get();
        }

        public static void setGlobalDatabase(String database) {
                if (database != null) {
                        globalDatabase.set(database);
                }
        }

        public static String getGlobalDatabase() {
                return (String) globalDatabase.get();
        }

        public static void removeGlobalDatabase() {
                globalDatabase.remove();
        }

        public static void setGlobalSchema(String schema) {
                if (schema != null) {
                        globalSchema.set(schema);
                }
        }

        public static void removeGlobalSchema() {
                globalSchema.remove();
        }

        public static String getGlobalSchema() {
                return (String) globalSchema.get();
        }

        public static void setGlobalHash(String hash) {
                if (hash != null) {
                        globalHash.set(hash);
                }
        }

        public static void removeGlobalHash() {
                globalHash.remove();
        }

        public static String getGlobalHash() {
                return (String) globalHash.get();
        }

        public static void setGlobalOraclePackage(OraclePackage currentOraclePackage) {
                if (currentOraclePackage != null) {
                        globalOraclePackage.set(currentOraclePackage);
                }
        }

        public static void removeGlobalOraclePackage() {
                globalOraclePackage.remove();
        }

        public static OraclePackage getGlobalOraclePackage() {
                return (OraclePackage) globalOraclePackage.get();
        }
        
        public static void setGlobalProcedure(TStoredProcedureSqlStatement procedureSqlStatement) {
                if (procedureSqlStatement != null) {
                        globalProcedure.set(procedureSqlStatement);
                }
        }

        public static void removeGlobalProcedure() {
                globalProcedure.remove();
                ModelBindingManager.get().cleanTempTable();
        }

        public static TStoredProcedureSqlStatement getGlobalProcedure() {
                return (TStoredProcedureSqlStatement) globalProcedure.get();
        }
        
        public static void setGlobalVendor(EDbVendor vendor) {
                if (vendor != null) {
                        globalVendor.set(vendor);
                }
        }

        public static void removeGlobalVendor() {
                globalVendor.remove();
        }

        public static EDbVendor getGlobalVendor() {
                return (EDbVendor) globalVendor.get();
        }

        public static void setGlobalSQLEnv(TSQLEnv sqlenv) {
                if (sqlenv != null) {
                        globalSQLEnv.set(sqlenv);
                }
        }

        public static void removeGlobalSQLEnv() {
                globalSQLEnv.remove();
        }

        public static TSQLEnv getGlobalSQLEnv() {
                return (TSQLEnv) globalSQLEnv.get();
        }

        public static String getGlobalServer() {
                TSQLEnv sqlEnv = getGlobalSQLEnv();
                if (sqlEnv != null)
                        return TSQLEnv.DEFAULT_SERVER_NAME.equals(sqlEnv.getDefaultServerName()) ? null : sqlEnv.getDefaultServerName();
                return null;
        }

        public static void setGlobalStmtStack(Stack<TCustomSqlStatement> stack) {
                if (stack != null) {
                        globalStmtStack.set(stack);
                }
        }

        public static void removeGlobalStmtStack() {
                globalStmtStack.remove();
        }
        
        public static void setGlobalSqlInfo(IndexedLinkedHashMap<String, List<SqlInfo>> sqlInfoMap) {
                if (sqlInfoMap != null) {
                        globalSqlInfo.set(sqlInfoMap);
                }
        }

        public static void removeGlobalSqlInfo() {
                globalSqlInfo.remove();
        }

        public static IndexedLinkedHashMap<String, List<SqlInfo>> getGlobalSqlInfo() {
                return (IndexedLinkedHashMap<String, List<SqlInfo>>) globalSqlInfo.get();
        }

        public static void setGlobalOption(Option option) {
                if (option != null) {
                        globalOption.set(option);
                }
        }
        
        public static Option getGlobalOption() {
                return (Option) globalOption.get();
        }

        public static void removeGlobalOption() {
                globalOption.remove();
        }

        public static Stack<TCustomSqlStatement> getGlobalStmtStack() {
                return (Stack<TCustomSqlStatement>) globalStmtStack.get();
        }

        public static void remove() {
                localManager.remove();
                globalDatabase.remove();
                globalSchema.remove();
                globalVendor.remove();
                globalSQLEnv.remove();
                globalHash.remove();
                globalStmtStack.remove();
                globalOption.remove();
                globalSqlInfo.remove();
        }

        public void bindModel(Object gspModel, Object relationModel) {
                if(gspModel == null) {
                        return;
                }
                modelBindingMap.put(gspModel, relationModel);

                TTable table = null;
                if (gspModel instanceof TTable && !(gspModel instanceof TCTE)) {
                        table = ((TTable) gspModel);
                } else if (gspModel instanceof Table) {
                        table = ((Table) gspModel).getTableObject();
                } else if (gspModel instanceof QueryTable) {
                        table = ((QueryTable) gspModel).getTableObject();
                } else if (gspModel instanceof TCTE) {
                        TTableList tables = ((TCTE) gspModel).getPreparableStmt().tables;
                        for (int j = 0; j < tables.size(); j++) {
                                TTable item = tables.getTable(j);
                                if (item != null && !SQLUtil.isEmpty(item.getAliasName())) {
                                        TCustomSqlStatement stmt = ((TCTE) gspModel).getPreparableStmt();
                                        if (tableHashMap.containsKey(stmt)) {
                                                tableAliasMap.put(
                                                                tableHashMap.get(stmt) + ":" + DlineageUtil.getIdentifierNormalTableName(item.getAliasName()),
                                                                item);
                                        } else {
                                                String sql = stmt.toString();
                                                if(sql == null){
                                                        System.err.println("Current statement toString() returns null.");
                                                        continue;
                                                }
                                                String hash = SHA256.getMd5(sql);
                                                tableHashMap.put(stmt, hash);
                                                tableAliasMap.put(hash + ":" + DlineageUtil.getIdentifierNormalTableName(item.getAliasName()), item);
                                        }
                                }

                                if (item != null) {
                                        tableSet.add(item);
                                }
                        }
                } else if (gspModel instanceof Pair && ((Pair) gspModel).first instanceof Table) {
                        table = ((Table) ((Pair) gspModel).first).getTableObject();
                }

                if (table == null && relationModel instanceof QueryTable) {
                        table = ((QueryTable) relationModel).getTableObject();
                }

                updateTableAliasMap(table);

                if (table != null) {
                        tableSet.add(table);
                }
                
                if(relationModel instanceof ResultSet) {
                        resultSetSet.add(relationModel);
                }
        }

        protected void updateTableAliasMap(TTable table) {
                if (table != null && !SQLUtil.isEmpty(table.getAliasName())) {
                        TCustomSqlStatement stmt = ModelBindingManager.getGlobalStmtStack().peek();
                        if (tableHashMap.containsKey(stmt)) {
                                tableAliasMap.put(tableHashMap.get(stmt) + ":" + DlineageUtil.getIdentifierNormalTableName(table.getAliasName()),
                                                table);
                        } else {
                                String sql = stmt.toString();
                                if(sql == null){
                                        System.err.println("Current statement toString() returns null.");
                                }
                                else {
                                        String hash = SHA256.getMd5(sql);
                                        tableHashMap.put(stmt, hash);
                                        tableAliasMap.put(hash + ":" + DlineageUtil.getIdentifierNormalTableName(table.getAliasName()),
                                                        table);
                                }
                        }
                }
        }

        public Object getModel(Object gspModel) {
                if (gspModel == null) {
                        return null;
                }

                if (gspModel instanceof TTable && !(gspModel instanceof TCTE)) {
                        TTable table = (TTable) gspModel;
                        if (table.getCTE() != null) {
                                Object result =  modelBindingMap.get(table.getCTE());
                                if (result != null) {
                                        return result;
                                }
                        }
                        if (table.getAliasClause() != null && table.getAliasClause().getColumns() != null) {
                                Object result = modelBindingMap.get(table.getAliasClause().getColumns());
                                if (result != null) {
                                        return result;
                                }
                        }
                        if (table.getSubquery() != null && !table.getSubquery().isCombinedQuery()) {
                                Object result =  modelBindingMap.get(table.getSubquery().getResultColumnList());
                                if (result != null) {
                                        return result;
                                }
                        }
                }
                if (gspModel instanceof TSelectSqlStatement) {
                        TSelectSqlStatement select = (TSelectSqlStatement) gspModel;
                        if (!select.isCombinedQuery()) {
                                if (select.getResultColumnList() != null) {
                                        Object result = modelBindingMap.get(select.getResultColumnList());
                                        if (result != null) {
                                                return result;
                                        }
                                }
                                else if (select.getTransformClause() != null) {
                                        Object result = modelBindingMap.get(select.getTransformClause());
                                        if (result != null) {
                                                return result;
                                        }
                                }
                        }
                }
                Object result = modelBindingMap.get(gspModel);
                if (result == null) {
                        result = createModelBindingMap.get(gspModel);
                }
                if (result == null) {
                        result = insertModelBindingMap.get(gspModel);
                }
                if (result == null) {
                        result = updateModelBindingMap.get(gspModel);
                }
                if (result == null) {
                        result = mergeModelBindingMap.get(gspModel);
                }
                if (result == null) {
                        result = viewModelBindingMap.get(gspModel);
                }
                if (result == null) {
                        result = cursorModelBindingMap.get(gspModel);
                }

                if (result == null && gspModel instanceof TTable) {
                        result = getCreateTable((TTable) gspModel);
                }

                if (result == null && gspModel instanceof TTable) {
                        result = (Table) getCreateModel((TTable) gspModel);
                }

                if (result == null && gspModel instanceof TTable) {
                        TTable table = (TTable) gspModel;
                        if (table.getLinkTable() != null) {
                                result = (Table) getTableByName(
                                                DlineageUtil.getTableFullName(table.getLinkTable().getTableName().toString()));
                                if (result == null) {
                                        result = (Table) getTableByName(
                                                        DlineageUtil.getTableFullNameWithDefaultSchema(table.getLinkTable().getTableName().toString()));
                                }
                        } else {
                                result = (Table) getTableByName(
                                                DlineageUtil.getTableFullName(((TTable) gspModel).getTableName().toString()));
                                if (result == null) {
                                        result = (Table) getTableByName(
                                                        DlineageUtil.getTableFullNameWithDefaultSchema(((TTable) gspModel).getTableName().toString()));
                                }
                        }
                }
                
                if (result == null && gspModel instanceof TTable) {
                        TTable table = (TTable) gspModel;
                        if(table.getFuncCall()!=null) {
                                result = getModel(table.getFuncCall());
                        }
                }
                
                if (result == null && gspModel instanceof TTable) {
                        TTable table = (TTable) gspModel;
                        Table tableModel = new Table(table);
                        result = (Table) getTableByName(DlineageUtil.getTableFullName(tableModel.getName()));
                }

                return result;
        }

        public List<Procedure> getProcedureModels(){
                List<Procedure> procedures = new ArrayList<Procedure>();
                for (Object obj : modelBindingMap.values()) {
                        if(obj instanceof Procedure && !procedures.contains(obj)){
                                procedures.add((Procedure)obj);
                        }
                }
                return procedures;
        }
        
        public List<OraclePackage> getOraclePackageModels(){
                List<OraclePackage> oraclePackages = new ArrayList<OraclePackage>();
                for (Object obj : modelBindingMap.values()) {
                        if(obj instanceof OraclePackage && !oraclePackages.contains(obj)){
                                oraclePackages.add((OraclePackage)obj);
                        }
                }
                return oraclePackages;
        }
        
        public List<Process> getProcessModels(){
                List<Process> processes = new ArrayList<Process>();
                for (Object obj : processModelBindingMap.values()) {
                        if(obj instanceof Process && !processes.contains(obj)){
                                processes.add((Process)obj);
                        }
                }
                return processes;
        }
        
        public void bindProcessModel(TParseTreeNode gspModel, Object relationModel) {
                processModelBindingMap.put(gspModel, relationModel);
        }

        public void unbindProcessModel(TParseTreeNode gspModel) {
                processModelBindingMap.remove(gspModel);
        }

        public Process getProcessModel(TParseTreeNode gspModel) {
                return (Process)processModelBindingMap.get(gspModel);
        }
        
        public void bindViewModel(Object gspModel, Object relationModel) {
                viewModelBindingMap.put(gspModel, relationModel);
        }
        
        public Object getViewModel(Object gspModel) {
                return viewModelBindingMap.get(gspModel);
        }

        public void bindUpdateModel(Object gspModel, Object relationModel) {
                updateModelBindingMap.put(gspModel, relationModel);
        }

        public Object getUpdateModel(Object gspModel) {
                return updateModelBindingMap.get(gspModel);
        }

        public void bindMergeModel(Object gspModel, Object relationModel) {
                mergeModelBindingMap.put(gspModel, relationModel);
        }

        public Object getMergeModel(Object gspModel) {
                return mergeModelBindingMap.get(gspModel);
        }

        public void bindInsertModel(Object gspModel, Object relationModel) {
                insertModelBindingMap.put(gspModel, relationModel);
        }

        public Object getInsertModel(Object gspModel) {
                return insertModelBindingMap.get(gspModel);
        }

        public void bindTableFunction(Object gspModel, Object functionTable) {
                if (functionTableMap.containsKey(gspModel)) {
                        ((Set) functionTableMap.get(gspModel)).add(functionTable);
                } else {
                        Set tableSet = new LinkedHashSet();
                        tableSet.add(functionTable);
                        functionTableMap.put(gspModel, tableSet);
                }
        }

        public Set<Object> getFunctionTable(Object gspModel) {
                Set<Object> result = (Set<Object>)functionTableMap.get(gspModel);
                if (result == null && gspModel instanceof String) {
                        for (Object key : functionTableMap.keySet()) {
                                if(!(key instanceof String)) {
                                        continue;
                                }
                                String keyString = (String) key;
                                String modelString = (String) gspModel;
                                
                                if (keyString.indexOf(".") != -1 && modelString.indexOf(".") == -1) {
                                        keyString = keyString.substring(keyString.lastIndexOf(".") + 1);
                                        if (keyString.equalsIgnoreCase(modelString)) {
                                                return (Set<Object>)functionTableMap.get(key);
                                        }
                                }
                                if (keyString.indexOf(".") == -1 && modelString.indexOf(".") != -1) {
                                        modelString = modelString.substring(modelString.lastIndexOf(".") + 1);
                                        if (keyString.equalsIgnoreCase(modelString)) {
                                                return (Set<Object>)functionTableMap.get(key);
                                        }
                                }
                                
                        }
                }
                return result;
        }

        public Table getCreateTable(TTable table) {
                if (table != null && table.getFullName() != null) {
                        return (Table) createModelQuickBindingMap.get(DlineageUtil.getTableFullName(table.getTableName().toString()));
                }
                if(modelBindingMap.get(table) instanceof Table) {
                        return (Table)modelBindingMap.get(table);
                }
                return null;
        }

        public Table getCreateModel(TTable table) {
                return (Table) createModelBindingMap.get(table);
        }

        public void bindCreateModel(TTable table, Table tableModel) {
                createModelBindingMap.put(table, tableModel);
                if (!createModelQuickBindingMap.containsKey(DlineageUtil.getTableFullName(table.getTableName().toString()))) {
                        createModelQuickBindingMap.put(DlineageUtil.getTableFullName(table.getTableName().toString()), tableModel);
                }
        }

        public void bindCreateModel(TObjectName tableName, Table tableModel) {
                if (!createModelQuickBindingMap.containsKey(DlineageUtil.getTableFullName(tableName.toString()))) {
                        createModelQuickBindingMap.put(DlineageUtil.getTableFullName(tableName.toString()), tableModel);
                }
        }
        
        public void bindCreateModel(String tableName, Table tableModel) {
                if (!createModelQuickBindingMap.containsKey(DlineageUtil.getTableFullName(tableName))) {
                        createModelQuickBindingMap.put(DlineageUtil.getTableFullName(tableName), tableModel);
                }
        }

        public TObjectName[] getTableColumns(TTable table) {
                Table createTable = getCreateTable(table);
                if (createTable != null) {
                        List<TableColumn> columnList = createTable.getColumns();
                        TObjectName[] columns = new TObjectName[columnList.size()];
                        for (int i = 0; i < columns.length; i++) {
                                columns[i] = columnList.get(i).getColumnObject();
                        }
                        Arrays.sort(columns, new Comparator<TObjectName>() {

                                @Override
                                public int compare(TObjectName o1, TObjectName o2) {
                                        if (o1 == null) {
                                                return -1;
                                        }
                                        if (o2 == null) {
                                                return 1;
                                        }
                                        return o1.getStartToken().posinlist - o2.getStartToken().posinlist;
                                }
                        });
                        return columns;
                }
                else if(modelBindingMap.get(table) instanceof QueryTable) {
                        QueryTable queryTable = (QueryTable)modelBindingMap.get(table);
                        List<TObjectName> columns = new ArrayList<TObjectName>();
                        for (ResultColumn resultColumn : queryTable.getColumns()) {
                                if(resultColumn.hasStarLinkColumn()) {
                                        for(TObjectName column: resultColumn.getStarLinkColumnList()) {
                                                columns.add(column);
                                        }
                                }
                                else if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                        TResultColumn columnObject = ((TResultColumn) resultColumn.getColumnObject());
                                        TAliasClause alias = columnObject.getAliasClause();
                                        if (alias != null && alias.getAliasName() != null) {
                                                if(resultColumn.isStruct() && resultColumn.getName().endsWith("*")) {
                                                        TObjectName structColumn = new TObjectName();
                                                        structColumn.setString("*");
                                                        columns.add(structColumn);
                                                }
                                                else {
                                                        columns.add(alias.getAliasName());
                                                }
                                        } else {
                                                if (columnObject.getFieldAttr() != null) {
                                                        columns.add(columnObject.getFieldAttr());
                                                } else {
                                                        TObjectName column = new TObjectName();
                                                        if (columnObject.getExpr().getExpressionType() == EExpressionType.typecast_t) {
                                                                column.setString(columnObject.getExpr().getLeftOperand().toString());
                                                        } else {
                                                                column.setString(columnObject.toString());
                                                        }
                                                        columns.add(column);
                                                }
                                        }
                                } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                        columns.add((TObjectName) resultColumn.getColumnObject());
                                }
                        }
                        return columns.toArray(new TObjectName[0]);
                }

                TObjectNameList list = table.getLinkedColumns();
                List<TObjectName> columns = new ArrayList<TObjectName>();

                if (table.getCTE() != null) {
                        ResultSet resultSet = (ResultSet) getModel(table.getCTE());
                        if (resultSet != null) {
                                List<ResultColumn> columnList = resultSet.getColumns();
                                for (int i = 0; i < columnList.size(); i++) {
                                        ResultColumn resultColumn = columnList.get(i);
                                        if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                                TResultColumn columnObject = ((TResultColumn) resultColumn.getColumnObject());
                                                TAliasClause alias = columnObject.getAliasClause();
                                                if (alias != null && alias.getAliasName() != null) {
                                                        columns.add(alias.getAliasName());
                                                } else {
                                                        if (columnObject.getFieldAttr() != null) {
                                                                columns.add(columnObject.getFieldAttr());
                                                        } else {
                                                                continue;
                                                        }
                                                }
                                        } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                                columns.add((TObjectName) resultColumn.getColumnObject());
                                        }
                                }
                        }
                } else if (list.size() == 1 && list.toString().indexOf("*") != -1 && table.getSubquery() != null) {
                        addSubqueryColumns(table, columns);
                } else {
                        for (int i = 0; i < list.size(); i++) {
                                TObjectName object = list.getObjectName(i);
                                if (object.toString().indexOf("*") != -1 && table.getSubquery() != null) {
                                        addSubqueryColumns(table, columns);
                                }
                                else 
                                        columns.add(object);
                        }
                }
                Collections.sort(columns, new Comparator<TObjectName>() {

                        @Override
                        public int compare(TObjectName o1, TObjectName o2) {
                                return o1.getStartToken().posinlist - o2.getStartToken().posinlist;
                        }
                });
                return columns.toArray(new TObjectName[0]);
        }

        private void addSubqueryColumns(TTable table, List<TObjectName> columns) {
                ResultSet resultSet = (ResultSet) getModel(table.getSubquery());
                if (resultSet != null) {
                        List<ResultColumn> columnList = resultSet.getColumns();
                        for (int i = 0; i < columnList.size(); i++) {
                                ResultColumn resultColumn = columnList.get(i);
                                if (resultColumn.getColumnObject() instanceof TResultColumn) {
                                        TResultColumn columnObject = ((TResultColumn) resultColumn.getColumnObject());
                                        TAliasClause alias = columnObject.getAliasClause();
                                        if (alias != null && alias.getAliasName() != null) {
                                                columns.add(alias.getAliasName());
                                        } else {
                                                if (columnObject.getFieldAttr() != null) {
                                                        columns.add(columnObject.getFieldAttr());
                                                } else {
                                                        TObjectName column = new TObjectName();
                                                        if (columnObject.getExpr().getExpressionType() == EExpressionType.typecast_t) {
                                                                column.setString(columnObject.getExpr().getLeftOperand().toString());
                                                        } else {
                                                                column.setString(columnObject.toString());
                                                        }
                                                        columns.add(column);
                                                }
                                        }
                                } else if (resultColumn.getColumnObject() instanceof TObjectName) {
                                        columns.add((TObjectName) resultColumn.getColumnObject());
                                }
                        }
                }
        }

        public TTable getTableFromColumn(TObjectName column) {
                if (column.getSourceTable() != null) {
                        return column.getSourceTable();
                }

                if (column.getTableString() != null && column.getTableString().trim().length() > 0) {
                        TCustomSqlStatement peekStmt = ModelBindingManager.getGlobalStmtStack().peek();
                        while (peekStmt != null) {
                                TTable table = null;
                                if (tableHashMap.containsKey(peekStmt)) {
                                        table = tableAliasMap.get(tableHashMap.get(peekStmt) + ":"
                                                        + DlineageUtil.getIdentifierNormalTableName(column.getTableString()));
                                }
                                if (table != null) {
                                        return table;
                                } else {
                                        peekStmt = peekStmt.getParentStmt();
                                }
                        }
                }
                return null;
        }
        
        public TTable getTable(TCustomSqlStatement stmt, TObjectName column) {
                if (column.getSourceTable() != null) {
                        return column.getSourceTable();
                }

                if (column.getTableString() != null && column.getTableString().trim().length() > 0) {
                        TCustomSqlStatement peekStmt = ModelBindingManager.getGlobalStmtStack().peek();
                        while (peekStmt != null) {
                                TTable table = null;
                                if (tableHashMap.containsKey(peekStmt)) {
                                        table = tableAliasMap.get(tableHashMap.get(peekStmt) + ":"
                                                        + DlineageUtil.getIdentifierNormalTableName(column.getTableString()));
                                }
                                if (table != null && table.getSubquery() != stmt)
                                        return table;
                                
                                if (peekStmt.getTables() != null) {
                                        for (TTable tableItem : peekStmt.getTables()) {
                                                if (DlineageUtil.getIdentifierNormalTableName(tableItem.getTableName().toString())
                                                                .equals(DlineageUtil.getIdentifierNormalTableName(column.getTableString()))) {
                                                        return tableItem;
                                                }
                                        }
                                }
                                
                                peekStmt = peekStmt.getParentStmt();
                        }
                }

                if (stmt.getTables() != null) {
                        for (int j = 0; j < stmt.getTables().size(); j++) {
                                TTable table = (TTable) stmt.getTables().getTable(j);
                                if (table.getSubquery() == stmt)
                                        continue;

                                TObjectName[] columns = getTableColumns(table);
                                for (int i = 0; i < columns.length; i++) {
                                        TObjectName columnName = columns[i];
                                        if (columnName == null || "*".equals(columnName.getColumnNameOnly()))
                                                continue;
                                        if (DlineageUtil.getIdentifierNormalColumnName(columnName.toString())
                                                        .equals(DlineageUtil.getIdentifierNormalColumnName(column.toString()))) {
                                                if (columnName.getSourceTable() == null || columnName.getSourceTable() == table) {
                                                        return table;
                                                }
                                        }
                                        if (!SQLUtil.isEmpty(columnName.getColumnNameOnly())
                                                        && DlineageUtil.getIdentifierNormalColumnName(columnName.getColumnNameOnly())
                                                                        .equals(DlineageUtil.getIdentifierNormalColumnName(column.getColumnNameOnly()))) {
                                                if (columnName.getSourceTable() == null || columnName.getSourceTable() == table) {
                                                        return table;
                                                }
                                        }
                                }
                        }
                }

                // Iterator iter = tableSet.iterator();
                // while (iter.hasNext()) {
                // TTable table = (TTable) iter.next();
                //
                // if (table.getSubquery() == stmt)
                // continue;
                //
                // if (table.getSubquery() != null) {
                // int start = table.getSubquery().getStartToken().posinlist;
                // int end = table.getSubquery().getEndToken().posinlist;
                // if (start <= stmt.getStartToken().posinlist && end >=
                // stmt.getEndToken().posinlist) {
                // continue;
                // }
                // }
                //
                // TObjectName[] columns = getTableColumns(table);
                // for (int i = 0; i < columns.length; i++) {
                // TObjectName columnName = columns[i];
                // if (columnName == null || "*".equals(columnName.getColumnNameOnly()))
                // continue;
                // if
                // (DlineageUtil.getIdentifierNormalName(columnName.toString()).equals(DlineageUtil.getIdentifierNormalName(column.toString())))
                // {
                // if (columnName.getSourceTable() == null
                // || columnName.getSourceTable() == table) {
                // return table;
                // }
                // }
                // if (columnName.getColumnNameOnly()!=null &&
                // DlineageUtil.getIdentifierNormalName(columnName.getColumnNameOnly()).equals(DlineageUtil.getIdentifierNormalName(column.getColumnNameOnly())))
                // {
                // if (columnName.getSourceTable() == null
                // || columnName.getSourceTable() == table) {
                // return table;
                // }
                // }
                // }
                // }
                return null;
        }

        public TTable guessTable(TCustomSqlStatement stmt, TObjectName column) {
                if (column.getTableString() != null && column.getTableString().trim().length() > 0) {
                        TCustomSqlStatement peekStmt = ModelBindingManager.getGlobalStmtStack().peek();
                        TTable table = null;
                        if (tableHashMap.containsKey(peekStmt)) {
                                table = tableAliasMap.get(
                                                tableHashMap.get(peekStmt) + ":" + DlineageUtil.getIdentifierNormalTableName(column.getTableString()));
                        }
                        if (table != null && table.getSubquery() != stmt)
                                return table;
                }

                Iterator iter = tableSet.iterator();
                while (iter.hasNext()) {
                        TTable table = (TTable) iter.next();

                        if (table.getSubquery() == stmt)
                                continue;

                        TObjectName[] columns = getTableColumns(table);
                        for (int i = 0; i < columns.length; i++) {
                                TObjectName columnName = columns[i];
                                if ("*".equals(columnName.getColumnNameOnly()))
                                        continue;
                                if (columnName.toString().equalsIgnoreCase(column.toString())) {
                                        if (columnName.getSourceTable() == null || columnName.getSourceTable() == table) {
                                                return table;
                                        }
                                }
                        }
                }
                return null;
        }

        public List<Table> getTablesByName() {
                List<Table> tables = new ArrayList<Table>();
                Iterator iter = tableNamesMap.values().iterator();
                while (iter.hasNext()) {
                        tables.add((Table) iter.next());
                }
                return tables;
        }

        public List<TTable> getBaseTables() {
                List<TTable> tables = new ArrayList<TTable>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }
                        TTable table = (TTable) key;
                        if (table.getSubquery() == null) {
                                tables.add(table);
                        }
                }

                iter = createModelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }
                        TTable table = (TTable) key;
                        tables.add(table);
                }

                iter = insertModelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }
                        TTable table = (TTable) key;
                        tables.add(table);
                }

                iter = mergeModelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }
                        TTable table = (TTable) key;
                        tables.add(table);
                }

                iter = updateModelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }
                        TTable table = (TTable) key;
                        if (!tables.contains(table)) {
                                tables.add(table);
                        }
                }

                return tables;
        }

        public List<TCustomSqlStatement> getViews() {
                List<TCustomSqlStatement> views = new ArrayList<TCustomSqlStatement>();

                Iterator iter = viewModelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TCreateViewSqlStatement) && !(key instanceof TCreateMaterializedSqlStatement)) {
                                continue;
                        }
                        TCustomSqlStatement view = (TCustomSqlStatement) key;
                        if (!views.contains(view)) {
                                views.add(view);
                        }
                }
                return views;
        }

        public List<TResultColumnList> getSelectResultSets() {
                List<TResultColumnList> resultSets = new ArrayList<TResultColumnList>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TResultColumnList)) {
                                continue;
                        }
                        TResultColumnList resultset = (TResultColumnList) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TObjectNameList> getQueryAliasTables() {
                List<TObjectNameList> resultSets = new ArrayList<TObjectNameList>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TObjectNameList)) {
                                continue;
                        }
                        TObjectNameList resultset = (TObjectNameList) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TSelectSqlStatement> getSelectSetResultSets() {
                List<TSelectSqlStatement> resultSets = new ArrayList<TSelectSqlStatement>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TSelectSqlStatement)) {
                                continue;
                        }

                        TSelectSqlStatement stmt = (TSelectSqlStatement) key;
                        if (stmt.getSetOperatorType() == ESetOperatorType.none)
                                continue;

                        resultSets.add(stmt);
                }
                return resultSets;
        }

        public List<TCTE> getCTEs() {
                List<TCTE> resultSets = new ArrayList<TCTE>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TCTE)) {
                                continue;
                        }

                        TCTE cte = (TCTE) key;
                        resultSets.add(cte);
                }
                return resultSets;
        }

        public List<TTable> getTableWithSelectSetResultSets() {
                List<TTable> resultSets = new ArrayList<TTable>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TTable)) {
                                continue;
                        }

                        if (((TTable) key).getSubquery() == null)
                                continue;
                        TSelectSqlStatement stmt = ((TTable) key).getSubquery();
                        if (stmt.getSetOperatorType() == ESetOperatorType.none)
                                continue;

                        resultSets.add((TTable) key);
                }
                return resultSets;
        }

        public List<TParseTreeNode> getMergeResultSets() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TMergeUpdateClause) && !(key instanceof TMergeInsertClause)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TParseTreeNode> getOutputResultSets() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TOutputClause)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TParseTreeNode> getUpdateResultSets() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TUpdateSqlStatement)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TParseTreeNode> getFunctoinCalls() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TFunctionCall) && !(key instanceof TCaseExpression)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public List<TParseTreeNode> getAliases() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TAliasClause)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }
        
        public List<TParseTreeNode> getCursors() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TCursorDeclStmt) && !(key instanceof TOpenforStmt)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }
        
        public List<TParseTreeNode> getPivotdTables() {
                List<TParseTreeNode> resultSets = new ArrayList<TParseTreeNode>();

                Iterator iter = modelBindingMap.keySet().iterator();
                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (!(key instanceof TPivotClause)) {
                                continue;
                        }
                        TParseTreeNode resultset = (TParseTreeNode) key;
                        resultSets.add(resultset);
                }
                return resultSets;
        }

        public void addRelation(Relationship relation) {
                if (relation != null && !relationHolder.contains(relation)) {
                        relationHolder.add(relation);
                }
        }
        
        public void removeRelation(ImpactRelationship relation) {
                if (relation != null) {
                        relationHolder.remove(relation);
                }
        }

        public Relationship[] getRelations() {
                return relationHolder.toArray(new Relationship[0]);
        }

        public void reset() {
                modelBindingMap.clear();
                processModelBindingMap.clear();
                viewModelBindingMap.clear();
                insertModelBindingMap.clear();
                createModelBindingMap.clear();
                createModelQuickBindingMap.clear();
                mergeModelBindingMap.clear();
                updateModelBindingMap.clear();
                cursorModelBindingMap.clear();
                functionTableMap.clear();
                tableNamesMap.clear();
                dropTables.clear();
                procedureNamesMap.clear();
                oraclePackageNamesMap.clear();
                relationHolder.clear();
                tableAliasMap.clear();
                tableHashMap.clear();
                topStmtHashMap.clear();
                hashSQLMap.clear();
                dynamicSQLMap.clear();
                tableSet.clear();
                resultSetSet.clear();
                dblinkTableSet.clear();
                objectTypeIndex.clear();
                collectionToElementTypeIndex.clear();
                pipelinedSignatures.clear();
                pendingPipelinedCallSites.clear();
                resolvingPipelinedFunctions.clear();
                DISPLAY_ID.clear();
                DISPLAY_NAME.clear();
                virtualTableNames.clear();
        }

        public void bindCursorModel(TCursorDeclStmt stmt, Variable resultSet) {
                String procedureName = DlineageUtil.getProcedureParentName(stmt);
                String variableString = stmt.getCursorName().toString();
                if (variableString.startsWith(":")) {
                        variableString = variableString.substring(variableString.indexOf(":") + 1);
                }
                if (!SQLUtil.isEmpty(procedureName)) {
                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                }
                createModelBindingMap.put(DlineageUtil.getTableFullName(variableString), resultSet);
        }
        
        public void bindCursorModel(TMssqlDeclare stmt, Variable resultSet) {
                String procedureName = DlineageUtil.getProcedureParentName(stmt);
                String variableString = stmt.getCursorName().toString();
                if (variableString.startsWith(":")) {
                        variableString = variableString.substring(variableString.indexOf(":") + 1);
                }
                if (!SQLUtil.isEmpty(procedureName)) {
                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                }
                createModelBindingMap.put(DlineageUtil.getTableFullName(variableString), resultSet);
        }
        
        public void bindCursorModel(TOpenforStmt stmt, Variable resultSet) {
                String procedureName = DlineageUtil.getProcedureParentName(stmt);
                String variableString = stmt.getCursorVariableName().toString();
                if (variableString.startsWith(":")) {
                        variableString = variableString.substring(variableString.indexOf(":") + 1);
                }
                if (!SQLUtil.isEmpty(procedureName)) {
                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                }
                createModelBindingMap.put(DlineageUtil.getTableFullName(variableString), resultSet);
        }
        
        public void bindCursorModel(TForStmt stmt, Variable resultSet) {
                String procedureName = DlineageUtil.getProcedureParentName(stmt);
                String variableString = stmt.getCursorName().toString();
                if (variableString.startsWith(":")) {
                        variableString = variableString.substring(variableString.indexOf(":") + 1);
                }
                if (!SQLUtil.isEmpty(procedureName)) {
                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                }
                createModelBindingMap.put(DlineageUtil.getTableFullName(variableString), resultSet);
        }
        
        public void bindCursorModel(TLoopStmt stmt, Variable resultSet) {
                String procedureName = DlineageUtil.getProcedureParentName(stmt);
                String variableString = stmt.getRecordName().toString();
                if (variableString.startsWith(":")) {
                        variableString = variableString.substring(variableString.indexOf(":") + 1);
                }
                if (!SQLUtil.isEmpty(procedureName)) {
                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                }
                createModelBindingMap.put(DlineageUtil.getTableFullName(variableString), resultSet);
        }

        public void bindCursorIndex(TObjectName indexName, TObjectName cursorName) {
                TCustomSqlStatement stmt = getGlobalStmtStack().peek();
                String procedureName = DlineageUtil.getProcedureParentName(stmt);
                String variableString = cursorName.toString();
                if (variableString.startsWith(":")) {
                        variableString = variableString.substring(variableString.indexOf(":") + 1);
                }
                if (!SQLUtil.isEmpty(procedureName)) {
                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                }
                
                Cursor cursor = ((Cursor) createModelBindingMap
                                .get(DlineageUtil.getTableFullName(variableString)));
                if (cursor != null) {
                        String indexNameString = indexName.toString();
                        if (!SQLUtil.isEmpty(procedureName)) {
                                indexNameString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(indexNameString);
                        }
                        bindModel(DlineageUtil.getTableFullName(indexNameString),
                                        modelBindingMap.get(cursor.getResultColumnObject()));
                        bindTableByName(DlineageUtil.getTableFullName(indexNameString),
                                        cursor);
                }
        }

        public List<TStoredProcedureSqlStatement> getProcedures() {
                List<TStoredProcedureSqlStatement> procedures = new ArrayList();
                Iterator iter = this.modelBindingMap.keySet().iterator();

                while (iter.hasNext()) {
                        Object key = iter.next();
                        if (key instanceof TStoredProcedureSqlStatement) {
                                TStoredProcedureSqlStatement procedure = (TStoredProcedureSqlStatement) key;
                                procedures.add(procedure);
                        }
                }

                return procedures;
        }

        // public void bindTableByName(TObjectName tableName, Table tableModel) {
        // tableNamesMap.put(tableName, tableModel);
        //
        // }
        //
        public void bindTableByName(String tableName, Table tableModel) {
                tableNamesMap.put(tableName, tableModel);

        }

        // public Table getTableByName(TObjectName tableName) {
        // return (Table)tableNamesMap.get(tableName);
        // }

        public Table getTableByName(String tableName) {
                Table table = (Table) tableNamesMap.get(tableName);
                if (table == null) {
                        TCustomSqlStatement stmt = getGlobalStmtStack().peek();
                        String procedureName = DlineageUtil.getProcedureParentName(stmt);
                        String variableString = tableName.toString();
                        if (!SQLUtil.isEmpty(procedureName)) {
                                String variableWithProcedure = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
                                if(tableNamesMap.containsKey(DlineageUtil.getTableFullName(variableWithProcedure))) {
                                        return  (Table) tableNamesMap.get(DlineageUtil.getTableFullName(variableWithProcedure));
                                }
                        }
                        return (Table) tableNamesMap.get(DlineageUtil.getTableFullName(variableString));
                } else {
                        return table;
                }
        }


        public void bindProcedureByName(String procedureName, Procedure procedureModel) {
                procedureNamesMap.put(procedureName, procedureModel);

        }
        
        public Procedure getProcedureByName(String procedureName) {
                if(procedureName == null){
                        return null;
                }

                if (ModelBindingManager.getGlobalOraclePackage() != null
                                && !procedureName.startsWith(ModelBindingManager.getGlobalOraclePackage().getName())) {
                        procedureName = ModelBindingManager.getGlobalOraclePackage().getName() + "." + procedureName;
                }
                Procedure procedure = (Procedure) procedureNamesMap.get(procedureName);
                if (procedure == null) {
                        if (procedureName.indexOf("(") == -1) {
                                for (Object name : procedureNamesMap.keySet()) {
                                        String fuctionName = name.toString();
                                        if (fuctionName.startsWith(procedureName + "(")) {
                                                return (Procedure) procedureNamesMap.get(name);
                                        }
                                        if (fuctionName.indexOf(".") != -1 && procedureName.indexOf(".") == -1) {
                                                fuctionName = fuctionName.substring(fuctionName.lastIndexOf(".") + 1);
                                                if (fuctionName.startsWith(procedureName + "(")) {
                                                        return (Procedure) procedureNamesMap.get(name);
                                                }
                                        }
                                        if (fuctionName.indexOf(".") == -1 && procedureName.indexOf(".") != -1) {
                                                String procedureNameSubstring = procedureName.substring(procedureName.lastIndexOf(".") + 1);
                                                if (fuctionName.startsWith(procedureNameSubstring + "(")) {
                                                        return (Procedure) procedureNamesMap.get(name);
                                                }
                                        }
                                }
                        }
                        else {
                                for (Object name : procedureNamesMap.keySet()) {
                                        String fuctionName = name.toString();
                                        if (fuctionName.startsWith(procedureName)) {
                                                return (Procedure) procedureNamesMap.get(name);
                                        }
                                        if (fuctionName.indexOf(".") != -1 && procedureName.indexOf(".") == -1) {
                                                fuctionName = fuctionName.substring(fuctionName.lastIndexOf(".") + 1);
                                                if (fuctionName.equalsIgnoreCase(procedureName)) {
                                                        return (Procedure) procedureNamesMap.get(name);
                                                }
                                        }
                                        if (fuctionName.indexOf(".") == -1 && procedureName.indexOf(".") != -1) {
                                                String procedureNameSubstring = procedureName.substring(procedureName.lastIndexOf(".") + 1);
                                                if (fuctionName.equalsIgnoreCase(procedureNameSubstring)) {
                                                        return (Procedure) procedureNamesMap.get(name);
                                                }
                                        }
                                }
                        }
                }
                return procedure;
        }
        
        public void bindOraclePackageByName(String oraclePackageName, OraclePackage oraclePackageModel) {
                oraclePackageNamesMap.put(oraclePackageName, oraclePackageModel);

        }
        
        public OraclePackage getOraclePackageByName(String oraclePackageName) {
                return (OraclePackage) oraclePackageNamesMap.get(oraclePackageName);
        }


        public String getSqlHash(TCustomSqlStatement stmt) {
                return topStmtHashMap.get(stmt);
        }

        public Map getHashSQLMap() {
                return hashSQLMap;
        }

        public Map getDynamicSQLMap() {
                return dynamicSQLMap;
        }

        public void collectSqlHash(TCustomSqlStatement stmt) {
                if (getGlobalOption().getAnalyzeMode() == AnalyzeMode.crud) {
                        String sql = stmt.toString();
                        if (sql != null) {
                                sql = stmt.getStartToken().lineNo + ":" + sql;
                                String hash = SQLUtil.stringToMD5(sql);
                                topStmtHashMap.put(stmt, hash);
                                hashSQLMap.put(hash, new Pair3<Long, Long, String>(stmt.getStartToken().lineNo, stmt.getEndToken().lineNo, ModelBindingManager.getGlobalHash()));
                        }
                } else {
                        try {
                                String sql = stmt.asCanonical();
                                if (sql != null) {
                                        String hash = SQLUtil.stringToMD5(sql);
                                        topStmtHashMap.put(stmt, hash);
                                        hashSQLMap.put(hash, sql);
                                }
                        } catch (Exception e) {
                                logger.error("collectSqlHash error: " + e.getMessage(), e);
                        }
                }
        }
        
        public void collectDynamicSqlHash(TCustomSqlStatement stmt) {
                if (getGlobalOption().getAnalyzeMode() == AnalyzeMode.dynamic) {
                        String sql = stmt.toString();
                        if (sql != null) {
                                sql = stmt.getStartToken().lineNo + ":" + sql;
                                String hash = SQLUtil.stringToMD5(sql);
                                dynamicSQLMap.put(hash, new Pair3<Long, Long, String>(stmt.getStartToken().lineNo, stmt.getEndToken().lineNo, ModelBindingManager.getGlobalHash()));
                        }
                }
        }

        public void appendDblinkTable(String name) {
                if (!SQLUtil.isEmpty(name)) {
                        dblinkTableSet.add(name);
                }
        }
        
        public boolean isDblinkTable(String name) {
                return dblinkTableSet.contains(name);
        }

        public Set<ResultSet> getResultSets() {
                return resultSetSet;
        }
        
        public void dropTable(Table table) {
                List tableNames = new ArrayList(tableNamesMap.keySet());
                for (Object tableName : tableNames) {
                        if(tableNamesMap.get(tableName) == table) {
                                tableNamesMap.remove(tableName);
                                dropTables.add(table);
                        }
                }
        }
        
        public void cleanTempTable() {
                Iterator<String> iter = tableNamesMap.keySet().iterator();
                while(iter.hasNext()) {
                        String tableName = iter.next();
                        if(DlineageUtil.isTempTable((Table)tableNamesMap.get(tableName), getGlobalVendor())) {
                                dropTables.add((Table)tableNamesMap.get(tableName));
                                iter.remove();
                        }
                }
        }

        public Set<Table> getDropTables() {
                return dropTables;
        }

        // --- Pipelined function stitching methods ---

        public void indexObjectType(String normalizedName, List<String> fieldNames) {
                objectTypeIndex.put(normalizedName, fieldNames);
        }

        public List<String> getObjectTypeFields(String normalizedName) {
                return objectTypeIndex.get(normalizedName);
        }

        public void indexCollectionType(String collectionName, String elementTypeName) {
                collectionToElementTypeIndex.put(collectionName, elementTypeName);
        }

        public String getElementTypeName(String collectionName) {
                return collectionToElementTypeIndex.get(collectionName);
        }

        public void addPipelinedSignature(PipelinedFunctionSignature sig) {
                pipelinedSignatures.computeIfAbsent(sig.getFunctionKey(), k -> new ArrayList<>()).add(sig);
                if (sig.getNakedKey() != null && !sig.getNakedKey().equals(sig.getFunctionKey())) {
                        pipelinedSignatures.computeIfAbsent(sig.getNakedKey(), k -> new ArrayList<>()).add(sig);
                }
        }

        public PipelinedFunctionSignature findPipelinedSignature(List<String> candidates, int argCount) {
                for (String key : candidates) {
                        List<PipelinedFunctionSignature> sigs = pipelinedSignatures.get(key);
                        if (sigs != null) {
                                PipelinedFunctionSignature match = null;
                                for (PipelinedFunctionSignature sig : sigs) {
                                        if (sig.getArgCount() == argCount || argCount < 0) {
                                                if (match != null) {
                                                        return null; // ambiguous
                                                }
                                                match = sig;
                                        }
                                }
                                if (match != null) {
                                        return match;
                                }
                        }
                }
                return null;
        }

        public PipelinedFunctionSignature findPipelinedSignatureAny(List<String> candidates) {
                for (String key : candidates) {
                        List<PipelinedFunctionSignature> sigs = pipelinedSignatures.get(key);
                        if (sigs != null && !sigs.isEmpty()) {
                                if (sigs.size() == 1) {
                                        return sigs.get(0);
                                }
                        }
                }
                return null;
        }

        public void addPendingPipelinedCallSite(PendingPipelinedCallSite callSite) {
                pendingPipelinedCallSites.add(callSite);
        }

        public List<PendingPipelinedCallSite> getPendingPipelinedCallSites() {
                return pendingPipelinedCallSites;
        }

        public Set<String> getResolvingPipelinedFunctions() {
                return resolvingPipelinedFunctions;
        }

        public Map<String, List<PipelinedFunctionSignature>> getPipelinedSignatures() {
                return pipelinedSignatures;
        }

}