001package gudusoft.gsqlparser.dlineage.util;
002
003import java.io.File;
004import java.util.ArrayList;
005import java.util.Arrays;
006import java.util.LinkedHashSet;
007import java.util.List;
008import java.util.Map;
009
010import gudusoft.gsqlparser.EDbVendor;
011import gudusoft.gsqlparser.EParameterMode;
012import gudusoft.gsqlparser.TCustomSqlStatement;
013import gudusoft.gsqlparser.dlineage.dataflow.model.AnalyzeMode;
014import gudusoft.gsqlparser.dlineage.dataflow.model.ModelBindingManager;
015import gudusoft.gsqlparser.dlineage.dataflow.model.SqlInfo;
016import gudusoft.gsqlparser.dlineage.dataflow.model.SubType;
017import gudusoft.gsqlparser.dlineage.dataflow.model.Table;
018import gudusoft.gsqlparser.dlineage.dataflow.model.xml.*;
019import gudusoft.gsqlparser.nodes.TFunctionCall;
020import gudusoft.gsqlparser.nodes.TObjectName;
021import gudusoft.gsqlparser.nodes.TParameterDeclaration;
022import gudusoft.gsqlparser.nodes.TParameterDeclarationList;
023import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
024import gudusoft.gsqlparser.sqlenv.TSQLEnv;
025import gudusoft.gsqlparser.stmt.TCommonBlock;
026import gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement;
027import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;
028import gudusoft.gsqlparser.stmt.teradata.TTeradataCreateProcedure;
029import gudusoft.gsqlparser.util.SQLUtil;
030import gudusoft.gsqlparser.util.functionChecker;
031import gudusoft.gsqlparser.util.keywordChecker;
032import gudusoft.gsqlparser.util.json.JSON;
033
034public class DlineageUtil {
035
036    public static boolean compareIdentifier(String source, String target, ESQLDataObjectType sqlDataObjectType) {
037        return SQLUtil.compareIdentifier(ModelBindingManager.getGlobalVendor(), sqlDataObjectType, source, target);
038    }
039
040    public static boolean compareColumnIdentifier(String source, String target) {
041        return SQLUtil.compareIdentifier(ModelBindingManager.getGlobalVendor(), ESQLDataObjectType.dotColumn, source,
042                target);
043    }
044
045    public static boolean compareTableIdentifier(String source, String target) {
046        return SQLUtil.compareIdentifier(ModelBindingManager.getGlobalVendor(), ESQLDataObjectType.dotTable, source,
047                target);
048    }
049
050        public static String getIdentifierNormalColumnName(String name) {
051                EDbVendor dbVendor = ModelBindingManager.getGlobalVendor();
052                return SQLUtil.getIdentifierNormalName(dbVendor, name, ESQLDataObjectType.dotColumn);
053        }
054
055        public static String getIdentifierNormalColumnName(String name, EDbVendor dbVendor) {
056                return SQLUtil.getIdentifierNormalName(dbVendor, name, ESQLDataObjectType.dotColumn);
057        }
058
059    public static String normalizeColumnName(String name) {
060        return SQLUtil.normalizeIdentifier(ModelBindingManager.getGlobalVendor(),  ESQLDataObjectType.dotColumn, name);
061    }
062    
063    public static String normalizeColumnName(String name, EDbVendor dbVendor) {
064        return SQLUtil.normalizeIdentifier(dbVendor,  ESQLDataObjectType.dotColumn, name);
065    }
066
067    
068    public static String getIdentifierNormalTableName(String name) {
069                if (ModelBindingManager.get() != null && ModelBindingManager.get().isDblinkTable(name)) {
070                        int index = name.lastIndexOf("@");
071                        if (index > 0) {
072                                return SQLUtil.getIdentifierNormalName(ModelBindingManager.getGlobalVendor(), name.substring(0, index),
073                                                ESQLDataObjectType.dotTable) + name.substring(index);
074                        } else {
075                                return name;
076                        }
077                }
078                if (name.endsWith(")") && name.indexOf("(") != -1) {
079                        return SQLUtil.getIdentifierNormalName(ModelBindingManager.getGlobalVendor(),
080                                        name.substring(0, name.lastIndexOf("(")), ESQLDataObjectType.dotTable)
081                                        + name.substring(name.lastIndexOf("("));
082                }
083        return SQLUtil.getIdentifierNormalName(ModelBindingManager.getGlobalVendor(), name,
084                ESQLDataObjectType.dotTable);
085    }
086
087    public static String getIdentifierNormalFunctionName(String name) {
088        return SQLUtil.getIdentifierNormalName(ModelBindingManager.getGlobalVendor(), name,
089                ESQLDataObjectType.dotFunction);
090    }
091
092    public static String getIdentifierNormalName(String name, ESQLDataObjectType sqlDataObjectType) {
093        return SQLUtil.getIdentifierNormalName(ModelBindingManager.getGlobalVendor(), name, sqlDataObjectType);
094    }
095
096    public static String getColumnName(TObjectName column) {
097        if (column == null) {
098            return null;
099        }
100        String name = column.getColumnNameOnly();
101        if (name == null || "".equals(name.trim())) {
102            return getIdentifierNormalColumnName(column.toString().trim());
103        } else
104            return getIdentifierNormalColumnName(name.trim());
105    }
106
107    public static boolean isTempTable(Table tableModel, EDbVendor vendor) {
108                if (SubType.temp_table == tableModel.getSubType()) {
109                        return true;
110                }
111        switch (vendor) {
112            case dbvmssql:
113            case dbvazuresql:
114                return tableModel.getName().startsWith("#") && !tableModel.getName().startsWith("##");
115            default:
116                return false;
117        }
118    }
119
120    public static String getTableFullName(String tableName) {
121                if (ModelBindingManager.get() != null && ModelBindingManager.get().isDblinkTable(tableName)) {
122                        return tableName;
123                }
124
125        if(tableName == null){
126            return null;
127        }
128
129        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
130                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
131                        tableName = SQLUtil.trimColumnStringQuote(tableName);
132                }
133        List<String> segments = SQLUtil.parseNames(tableName);
134        if (segments.size() == 1) {
135            StringBuffer buffer = new StringBuffer();
136            if (ModelBindingManager.getGlobalDatabase() != null) {
137                buffer.append(ModelBindingManager.getGlobalDatabase()).append(".");
138            }
139            if (ModelBindingManager.getGlobalSchema() != null) {
140                buffer.append(ModelBindingManager.getGlobalSchema()).append(".");
141            }
142            buffer.append(tableName);
143            return getIdentifierNormalTableName(buffer.toString());
144        } else if (segments.size() == 2) {
145            if (ModelBindingManager.getGlobalDatabase() != null) {
146                return getIdentifierNormalTableName(ModelBindingManager.getGlobalDatabase() + "." + tableName);
147            } else {
148                return getIdentifierNormalTableName(tableName);
149            }
150        } else {
151            if ((ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql
152                    || ModelBindingManager.getGlobalVendor() == EDbVendor.dbvazuresql) && tableName.indexOf("..") != -1) {
153                if (ModelBindingManager.getGlobalSchema() != null) {
154                    return getIdentifierNormalTableName(
155                            tableName.replace("..", "." + ModelBindingManager.getGlobalSchema() + "."));
156                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql
157                        || ModelBindingManager.getGlobalVendor() == EDbVendor.dbvazuresql) {
158                    return getIdentifierNormalTableName(tableName.replace("..", ".dbo."));
159                } else {
160                    return getIdentifierNormalTableName(tableName);
161                }
162            } else {
163                return getIdentifierNormalTableName(tableName);
164            }
165        }
166    }
167
168
169    
170    public static String getSimpleTableName(String tableName) {
171        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
172                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
173                        tableName = SQLUtil.trimColumnStringQuote(tableName);
174                }
175        List<String> segments = SQLUtil.parseNames(tableName);
176        return segments.get(segments.size()-1);
177    }
178    
179    public static String getColumnNameOnly(String columnName) {
180        if (columnName.startsWith("`") && columnName.endsWith("`") && columnName.indexOf(".") != -1
181                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
182                columnName = SQLUtil.trimColumnStringQuote(columnName);
183                }
184        List<String> segments = SQLUtil.parseNames(columnName);
185        return segments.get(segments.size()-1);
186    }
187
188    public static String getTableSchema(String tableName) {
189        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
190        boolean supportSchema = TSQLEnv.supportSchema(vendor);
191
192        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
193                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
194            tableName = SQLUtil.trimColumnStringQuote(tableName);
195        }
196        List<String> segments = SQLUtil.parseNames(tableName);
197        if (segments.size() == 1) {
198            if (supportSchema && ModelBindingManager.getGlobalSchema() != null) {
199                return ModelBindingManager.getGlobalSchema();
200            }
201        } else if (segments.size() == 2) {
202            if(supportSchema) {
203                return segments.get(0);
204            }
205        } else {
206            if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql && tableName.indexOf("..") != -1) {
207                if (ModelBindingManager.getGlobalSchema() != null) {
208                    return ModelBindingManager.getGlobalSchema();
209                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
210                    return "dbo";
211                }
212            } else {
213                if(supportSchema) {
214                    return segments.get(segments.size() - 2);
215                }
216            }
217        }
218        return null;
219    }
220
221    public static String getTableServer(String tableName) {
222        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
223        boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
224        boolean supportSchema = TSQLEnv.supportSchema(vendor);
225
226        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
227                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
228            tableName = SQLUtil.trimColumnStringQuote(tableName);
229        }
230        List<String> segments = SQLUtil.parseNames(tableName);
231        if (segments.size() <= 2) {
232            return ModelBindingManager.getGlobalServer();
233        } else if (segments.size() == 3) {
234            if(supportCatalog && supportSchema) {
235                return ModelBindingManager.getGlobalServer();
236            } else {
237                return segments.get(0);
238            }
239        } else {
240            if(supportCatalog && supportSchema) {
241                    return segments.get(segments.size() - 4);
242            } else {
243                return segments.get(segments.size() - 3);
244            }
245        }
246    }
247
248    public static String getTableDatabase(String tableName) {
249        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
250        boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
251        boolean supportSchema = TSQLEnv.supportSchema(vendor);
252
253        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
254                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
255                        tableName = SQLUtil.trimColumnStringQuote(tableName);
256                }
257        List<String> segments = SQLUtil.parseNames(tableName);
258        if (segments.size() == 1) {
259            if (supportCatalog && ModelBindingManager.getGlobalDatabase() != null) {
260                return ModelBindingManager.getGlobalDatabase();
261            }
262        } else if (segments.size() == 2) {
263            if(supportCatalog && supportSchema) {
264                if (ModelBindingManager.getGlobalDatabase() != null) {
265                    return ModelBindingManager.getGlobalDatabase();
266                }
267            } else {
268                if (supportCatalog) {
269                    return segments.get(0);
270                }
271            }
272        } else {
273            if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql && tableName.indexOf("..") != -1) {
274                String fullName = tableName;
275                if (ModelBindingManager.getGlobalSchema() != null) {
276                    fullName = getIdentifierNormalTableName(
277                            tableName.replace("..", "." + ModelBindingManager.getGlobalSchema() + "."));
278                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
279                    fullName = getIdentifierNormalTableName(tableName.replace("..", ".dbo."));
280                } else {
281                    fullName = getIdentifierNormalTableName(tableName);
282                }
283                return getTableDatabase(fullName);
284            } else {
285                if(supportCatalog && supportSchema) {
286                    return segments.get(segments.size() - 3);
287                }
288                else if(supportCatalog){
289                    return segments.get(segments.size() - 2);
290                }
291            }
292        }
293        return null;
294    }
295
296    public static String getTableFullNameWithDefaultSchema(String tableName) {
297        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
298        boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
299        boolean supportSchema = TSQLEnv.supportSchema(vendor);
300
301        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
302                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
303                        tableName = SQLUtil.trimColumnStringQuote(tableName);
304                }
305        List<String> segments = SQLUtil.parseNames(tableName);
306        if (segments.size() == 1) {
307            StringBuffer buffer = new StringBuffer();
308            if (supportCatalog && ModelBindingManager.getGlobalDatabase() != null) {
309                buffer.append(ModelBindingManager.getGlobalDatabase()).append(".");
310            }
311            if (supportSchema && ModelBindingManager.getGlobalSchema() != null) {
312                buffer.append(ModelBindingManager.getGlobalSchema()).append(".");
313            } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
314                buffer.append("dbo").append(".");
315            }
316            buffer.append(tableName);
317            return getIdentifierNormalTableName(buffer.toString());
318        } else if (segments.size() == 2) {
319            if (supportCatalog && supportSchema && ModelBindingManager.getGlobalDatabase() != null) {
320                return getIdentifierNormalTableName(ModelBindingManager.getGlobalDatabase() + "." + tableName);
321            } else {
322                return getIdentifierNormalTableName(tableName);
323            }
324        } else {
325            if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql && tableName.indexOf("..") != -1) {
326                if (ModelBindingManager.getGlobalSchema() != null) {
327                    return getIdentifierNormalTableName(
328                            tableName.replace("..", "." + ModelBindingManager.getGlobalSchema() + "."));
329                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
330                    return getIdentifierNormalTableName(tableName.replace("..", ".dbo."));
331                } else {
332                    return getIdentifierNormalTableName(tableName);
333                }
334            } else {
335                return getIdentifierNormalTableName(tableName);
336            }
337        }
338    }
339
340    @SuppressWarnings("rawtypes")
341    public static SqlInfo[] convertSQL(File file, String json) {
342        List<SqlInfo> sqlInfos = new ArrayList<SqlInfo>();
343        try {
344            List sqlContents = (List) JSON.parseObject(json);
345            for (int j = 0; j < sqlContents.size(); j++) {
346                Map sqlContent = (Map) sqlContents.get(j);
347                String sql = (String) sqlContent.get("sql");
348                String fileName = (String) sqlContent.get("fileName");
349                String filePath = (String) sqlContent.get("filePath");
350                if (sql != null && sql.trim().startsWith("{")) {
351                    Map queryObject = (Map) JSON.parseObject(sql);
352                    List querys = (List) queryObject.get("queries");
353                    if (querys != null) {
354                        for (int i = 0; i < querys.size(); i++) {
355                            Map object = (Map) querys.get(i);
356                            SqlInfo info = new SqlInfo();
357                            info.setSql(JSON.toJSONString(object));
358                            info.setFileName(fileName);
359                            info.setFilePath(filePath);
360                            info.setOriginIndex(i);
361                            sqlInfos.add(info);
362                        }
363                    } else {
364                        SqlInfo info = new SqlInfo();
365                        info.setSql(JSON.toJSONString(queryObject));
366                        info.setFileName(fileName);
367                        info.setFilePath(filePath);
368                        info.setOriginIndex(0);
369                        sqlInfos.add(info);
370                    }
371                } else if (sql != null) {
372                    SqlInfo info = new SqlInfo();
373                    info.setSql(sql);
374                    info.setFileName(fileName);
375                    info.setFilePath(filePath);
376                    info.setOriginIndex(0);
377                    sqlInfos.add(info);
378                }
379            }
380        } catch (Exception e) {
381            try {
382                Map queryObject = (Map) JSON.parseObject(json);
383                List querys = (List) queryObject.get("queries");
384                if (querys != null) {
385                    for (int i = 0; i < querys.size(); i++) {
386                        Map object = (Map) querys.get(i);
387                        SqlInfo info = new SqlInfo();
388                        info.setSql(JSON.toJSONString(object));
389                        if (file != null) {
390                            info.setFileName(file.getName());
391                            info.setFilePath(file.getAbsolutePath());
392                        }
393                        info.setOriginIndex(i);
394                        sqlInfos.add(info);
395                    }
396                } else {
397                    SqlInfo info = new SqlInfo();
398                    info.setSql(JSON.toJSONString(queryObject));
399                    if (file != null) {
400                        info.setFileName(file.getName());
401                        info.setFilePath(file.getAbsolutePath());
402                    }
403                    info.setOriginIndex(0);
404                    sqlInfos.add(info);
405                }
406            } catch (Exception e1) {
407                SqlInfo info = new SqlInfo();
408                info.setSql(json);
409                if (file != null) {
410                    info.setFileName(file.getName());
411                    info.setFilePath(file.getAbsolutePath());
412                }
413                info.setOriginIndex(0);
414                sqlInfos.add(info);
415            }
416        }
417        return sqlInfos.toArray(new SqlInfo[0]);
418    }
419
420    
421        public static String getQualifiedTableName(table table) {
422                boolean supportCatalog = TSQLEnv.supportCatalog(ModelBindingManager.getGlobalVendor());
423                boolean supportSchema = TSQLEnv.supportSchema(ModelBindingManager.getGlobalVendor());
424                StringBuilder buffer = new StringBuilder();
425                if (supportCatalog && supportSchema) {
426                        if (!SQLUtil.isEmpty(table.getDatabase())) {
427                                if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvoracle
428                                                && SubType.dblink.name().equals(table.getSubType())) {
429                                        //dblink doesn't set database
430                                } else {
431                                        buffer.append(table.getDatabase());
432                                }
433                        }
434                        if (!SQLUtil.isEmpty(table.getSchema())) {
435                                if (buffer.length() > 0) {
436                                        buffer.append(".");
437                                }
438                                buffer.append(table.getSchema());
439                        } else {
440                                if (buffer.length() > 0) {
441                                        buffer.append(".");
442                                        if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
443                                                buffer.append("dbo");
444                                        } else {
445                                                buffer.append(TSQLEnv.DEFAULT_SCHEMA_NAME);
446                                        }
447                                }
448                        }
449                        if (buffer.length() > 0) {
450                                buffer.append(".");
451                        }
452                        buffer.append(table.getTableNameOnly());
453                }
454                else if(supportCatalog) {
455                        if (!SQLUtil.isEmpty(table.getDatabase())) {
456                                buffer.append(table.getDatabase());
457                        }
458                        if (buffer.length() > 0) {
459                                buffer.append(".");
460                        }
461                        buffer.append(table.getTableNameOnly());
462                }
463                else if(supportSchema) {
464                        if (!SQLUtil.isEmpty(table.getSchema())) {
465                                buffer.append(table.getSchema());
466                        }
467                        if (buffer.length() > 0) {
468                                buffer.append(".");
469                        }
470                        buffer.append(table.getTableNameOnly());
471                }
472                if (SubType.dblink.name().equals(table.getSubType())) {
473                        buffer.append("@").append(table.getDatabase());
474                }
475                return buffer.toString();
476        }
477
478    public static TCustomSqlStatement getTopStmt(TCustomSqlStatement stmt) {
479        if (ModelBindingManager.getGlobalOption() != null && ModelBindingManager.getGlobalOption().getAnalyzeMode() == AnalyzeMode.crud) {
480            TCustomSqlStatement parent = stmt.getParentStmt();
481            if (parent == null || parent instanceof TPlsqlCreatePackage
482                    || parent instanceof TStoredProcedureSqlStatement || parent instanceof TCommonBlock)
483                return stmt;
484            return getTopStmt(parent);
485        } else {
486            TCustomSqlStatement parent = stmt.getParentStmt();
487            if (parent == null || parent instanceof TPlsqlCreatePackage)
488                return stmt;
489            return getTopStmt(parent);
490        }
491    }
492
493    public static boolean isQuote(String column) {
494        return (column.startsWith("\"") && column.endsWith("\"")) || (column.startsWith("'") && column.endsWith("'"))
495                || (column.startsWith("[") && column.endsWith("]")) || (column.startsWith("`") && column.endsWith("`"));
496    }
497
498    public static String getProcedureNameWithArgs(TStoredProcedureSqlStatement stmt) {
499                StringBuilder buffer = new StringBuilder();
500                buffer.append(stmt.getStoredProcedureName().toString());
501                if (stmt.getParameterDeclarations() != null && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
502                        buffer.append("(");
503                        TParameterDeclarationList parameters = stmt.getParameterDeclarations();
504                        for (int i = 0; i < parameters.size(); ++i) {
505                                TParameterDeclaration parameter = parameters.getParameterDeclarationItem(i);
506                                if(parameter.getDataType()!=null) {
507                                        buffer.append(parameter.getDataType().getDataTypeName());
508                                }
509                                if(i<parameters.size()-1) {
510                                        buffer.append(",");
511                                }
512                        }
513                        buffer.append(")");
514                }
515                return buffer.toString();
516        }
517
518    public static String getIdentifierProcedureNameWithArgNum(procedure procedure) {
519        StringBuilder buffer = new StringBuilder();
520        buffer.append(SQLUtil.trimColumnStringQuote(procedure.getName()));
521        if (procedure.getArguments() != null && procedure.getArguments().size() > 0 && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
522            buffer.append("(");
523            buffer.append(procedure.getArguments().size());
524            buffer.append(")");
525        }
526        return buffer.toString().toUpperCase();
527    }
528
529    public static String getIdentifierOraclePackageNameWithArgNum(oraclePackage pkg) {
530        StringBuilder buffer = new StringBuilder();
531        buffer.append(SQLUtil.trimColumnStringQuote(pkg.getName()));
532        if (pkg.getArguments() != null && pkg.getArguments().size() > 0 && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
533            buffer.append("(");
534            buffer.append(pkg.getArguments().size());
535            buffer.append(")");
536        }
537        return buffer.toString().toUpperCase();
538    }
539
540    public static String getIdentifierFunctionName(table function) {
541        StringBuilder buffer = new StringBuilder();
542        buffer.append(SQLUtil.trimColumnStringQuote(function.getName()));
543        return buffer.toString().toUpperCase();
544    }
545
546    public static String getProcedureNameWithArgNum(TStoredProcedureSqlStatement stmt) {
547                StringBuilder buffer = new StringBuilder();
548                buffer.append(stmt.getStoredProcedureName().toString());
549                if (stmt.getParameterDeclarations() != null && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
550                        buffer.append("(");
551                        buffer.append(stmt.getParameterDeclarations().size());
552                        buffer.append(")");
553                }
554                return buffer.toString();
555        }
556    
557        public static String getProcedureNameWithInputArgNum(TStoredProcedureSqlStatement stmt) {
558                StringBuilder buffer = new StringBuilder();
559                buffer.append(stmt.getStoredProcedureName().toString());
560                if (stmt.getParameterDeclarations() != null && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
561                        buffer.append("(");
562                        int count = 0;
563                        for (int i = 0; i < stmt.getParameterDeclarations().size(); i++) {
564                                if (stmt.getParameterDeclarations().getParameterDeclarationItem(i)
565                                                .getParameterMode() == EParameterMode.in) {
566                                        count++;
567                                }
568                        }
569                        if (count == 0) {
570                                count = stmt.getParameterDeclarations().size();
571                        }
572                        buffer.append(count);
573                        buffer.append(")");
574                }
575                return buffer.toString();
576        }
577
578        public static String getFunctionNameWithArgNum(TFunctionCall function) {
579                StringBuilder buffer = new StringBuilder();
580                buffer.append(function.getFunctionName().toString());
581                if (function.getArgs() != null && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
582                        buffer.append("(");
583                        buffer.append(function.getArgs().size());
584                        buffer.append(")");
585                }
586                return buffer.toString();
587        }
588
589        public static String getTableSchema(Table tableModel) {
590                StringBuilder buffer = new StringBuilder();
591                if(tableModel.getDatabase()!=null) {
592                        buffer.append(tableModel.getDatabase());
593                }
594                else {
595                        buffer.append(TSQLEnv.DEFAULT_DB_NAME);
596                }
597                buffer.append(".");
598                if(tableModel.getSchema()!=null) {
599                        buffer.append(tableModel.getSchema());
600                }
601                else {
602                        buffer.append(TSQLEnv.DEFAULT_SCHEMA_NAME);
603                }
604                return buffer.toString();
605        }
606        
607        public static String getTableSQLEnvKey(Table tableModel) {
608                StringBuilder buffer = new StringBuilder();
609                if(tableModel.getDatabase()!=null) {
610                        buffer.append(tableModel.getDatabase());
611                }
612                else {
613                        buffer.append(TSQLEnv.DEFAULT_DB_NAME);
614                }
615                buffer.append(".");
616                if(tableModel.getSchema()!=null) {
617                        buffer.append(tableModel.getSchema());
618                }
619                else {
620                        buffer.append(TSQLEnv.DEFAULT_SCHEMA_NAME);
621                }
622                buffer.append(".");
623                buffer.append(DlineageUtil.getSimpleTableName(tableModel.getName()));
624                return buffer.toString();
625        }
626        
627        public static String getProcedureParentName(TCustomSqlStatement stmt) {
628                if (stmt instanceof TStoredProcedureSqlStatement) {
629                        if (((TStoredProcedureSqlStatement) stmt).getStoredProcedureName() != null) {
630                                return getOraclePackageName() + ((TStoredProcedureSqlStatement) stmt).getStoredProcedureName().toString();
631                        }
632                }
633                stmt = stmt.getParentStmt();
634                if (stmt == null)
635                        return null;
636
637        if (stmt instanceof TCommonBlock) {
638                        if(((TCommonBlock) stmt).getBlockBody().getParentObjectName() instanceof TStoredProcedureSqlStatement) {
639                                stmt = (TStoredProcedureSqlStatement)((TCommonBlock) stmt).getBlockBody().getParentObjectName();
640                        }
641                }
642        
643                if (stmt instanceof TStoredProcedureSqlStatement) {
644                        if (((TStoredProcedureSqlStatement) stmt).getStoredProcedureName() != null) {
645                                String procedureName = getOraclePackageName() + ((TStoredProcedureSqlStatement) stmt).getStoredProcedureName().toString();
646                return getTableFullName(procedureName);
647                        }
648                }
649                if (stmt instanceof TTeradataCreateProcedure) {
650                        if (((TTeradataCreateProcedure) stmt).getProcedureName() != null) {
651                                String procedureName =  ((TTeradataCreateProcedure) stmt).getProcedureName().toString();
652                return getTableFullName(procedureName);
653                        }
654                }
655
656                return getProcedureParentName(stmt);
657        }
658
659        private static String getOraclePackageName() {
660                if (ModelBindingManager.getGlobalOraclePackage() != null) {
661                        return ModelBindingManager.getGlobalOraclePackage().getName() + ".";
662                }
663                return "";
664        }
665
666        public static sourceColumn copySourceColumn(sourceColumn oldSourceName) {
667                sourceColumn newSourceColumn = new sourceColumn();
668                newSourceColumn.setClauseType(oldSourceName.getClauseType());
669                newSourceColumn.setColumn(oldSourceName.getColumn());
670                newSourceColumn.setColumn_type(oldSourceName.getColumn_type());
671                newSourceColumn.setCoordinate(oldSourceName.getCoordinate());
672                newSourceColumn.setId(oldSourceName.getId());
673                newSourceColumn.setName(oldSourceName.getName());
674                newSourceColumn.setParent_alias(oldSourceName.getParent_alias());
675                newSourceColumn.setParent_id(oldSourceName.getParent_id());
676                newSourceColumn.setParent_name(oldSourceName.getParent_name());
677                newSourceColumn.setSource(oldSourceName.getSource());
678                newSourceColumn.setSource_id(oldSourceName.getSource_id());
679                newSourceColumn.setSource_name(oldSourceName.getSource_name());
680                newSourceColumn.setStruct(oldSourceName.isStruct());
681                newSourceColumn.setType(oldSourceName.getType());
682                newSourceColumn.setValue(oldSourceName.getValue());
683                if(oldSourceName.getTransforms()!=null) {
684                        newSourceColumn.setTransforms(new LinkedHashSet<transform>());
685                        for(transform transform: oldSourceName.getTransforms()) {
686                                newSourceColumn.getTransforms().add(transform);
687                        }
688                }
689                if(oldSourceName.getCandidateParents()!=null) {
690                        newSourceColumn.setCandidateParents(new LinkedHashSet<candidateTable>());
691                        for(candidateTable candidateTable: oldSourceName.getCandidateParents()) {
692                                newSourceColumn.getCandidateParents().add(candidateTable);
693                        }
694                }
695                return newSourceColumn;
696        }
697
698        public static boolean supportFunctionOverride(EDbVendor vendor) {
699                switch (vendor) {
700                case dbvpostgresql:
701                case dbvoracle:
702                case dbvdb2:
703                case dbvmysql:
704                case dbvsnowflake:
705                case dbvhana:
706                case dbvgreenplum:
707                case dbvgaussdb:
708                        return true;
709                default:
710                        return false;
711                }
712        }
713        
714        private static final List<String> TERADATA_BUILTIN_FUNCTIONS = Arrays
715                        .asList(new String[] { "ACCOUNT", "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
716                                        "CURRENT_USER", "DATABASE", "DATE", "PROFILE", "ROLE", "SESSION", "TIME", "USER", "SYSDATE", });
717        
718        public static boolean isBuiltInFunctionName(String functionName) {
719                if (functionName == null)
720                        return false;
721                try {
722                        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
723                        if (vendor == EDbVendor.dbvteradata) {
724                                boolean result = TERADATA_BUILTIN_FUNCTIONS.contains(functionName.toUpperCase());
725                                if (result) {
726                                        return true;
727                                }
728                        }
729
730                        List<String> versions = functionChecker.getAvailableDbVersions(vendor);
731                        if (versions != null && versions.size() > 0) {
732                                for (int i = 0; i < versions.size(); i++) {
733                                        boolean result = functionChecker.isBuiltInFunction(functionName.toUpperCase(),
734                                                        vendor, versions.get(i));
735                                        if (result) {
736                                                return result;
737                                        }
738                                }
739
740                                // boolean result =
741                                // TERADATA_BUILTIN_FUNCTIONS.contains(object.toString());
742                                // if (result) {
743                                // return true;
744                                // }
745                        }
746                } catch (Exception e) {
747                }
748
749                return false;
750        }
751        
752        public static boolean isKeyword(String objectName) {
753                if (objectName == null)
754                        return false;
755                try {
756                        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
757
758                        List<String> versions = keywordChecker.getAvailableDbVersions(vendor);
759                        if (versions != null && versions.size() > 0) {
760                                for (int i = 0; i < versions.size(); i++) {
761                                        List<String> segments = SQLUtil.parseNames(objectName);
762                                        boolean result = keywordChecker.isKeyword(segments.get(segments.size() - 1),
763                                                        vendor, versions.get(i), false);
764                                        if (result) {
765                                                return result;
766                                        }
767                                }
768                        }
769                } catch (Exception e) {
770                }
771
772                return false;
773        }
774}