typesql-cli 0.15.1 → 0.15.3

package/postgres-query-analyzer/traverse.js

@@ -1,18 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOptions = defaultOptions;
 exports.traverseSmt = traverseSmt;
 const PostgreSQLParser_1 = require("@wsporto/typesql-parser/postgres/PostgreSQLParser");
 const typesql_parser_1 = require("@wsporto/typesql-parser");
 const select_columns_1 = require("../mysql-query-analyzer/select-columns");
-function traverseSmt(stmt, dbSchema) {
+function defaultOptions() {
+    return {
+        collectNestedInfo: false,
+        collectDynamicQueryInfo: false
+    };
+}
+function traverseSmt(stmt, dbSchema, options) {
+    const { collectNestedInfo = false, collectDynamicQueryInfo = false } = options;
     const traverseResult = {
         columnsNullability: [],
         parameters: [],
         singleRow: false
     };
+    if (collectNestedInfo) {
+        traverseResult.relations = [];
+    }
+    if (collectDynamicQueryInfo) {
+        const dynamicQueryInfo = {
+            with: [],
+            select: [],
+            from: [],
+            where: []
+        };
+        traverseResult.dynamicQueryInfo = dynamicQueryInfo;
+    }
+    const traverseContext = {
+        dbSchema,
+        collectNestedInfo,
+        collectDynamicQueryInfo,
+        fromColumns: []
+    };
     const selectstmt = stmt.selectstmt();
     if (selectstmt) {
-        const result = traverseSelectstmt(selectstmt, dbSchema, [], traverseResult);
+        const result = traverseSelectstmt(selectstmt, traverseContext, traverseResult);
         return result;
     }
     const insertstmt = stmt.insertstmt();
@@ -42,114 +68,183 @@ function collectContextsOfType(ctx, targetType) {
     });
     return results;
 }
-function traverseSelectstmt(selectstmt, dbSchema, fromColumns, traverseResult) {
+function traverseSelectstmt(selectstmt, context, traverseResult) {
     const result = collectContextsOfType(selectstmt, PostgreSQLParser_1.C_expr_exprContext).filter(c_expr => c_expr.PARAM());
     const paramIsListResult = result.map(param => paramIsList(param));
-    const columns = traverse_selectstmt(selectstmt, dbSchema, fromColumns, traverseResult);
+    const columns = traverse_selectstmt(selectstmt, context, traverseResult);
     //select parameters are collected after from paramters
     traverseResult.parameters.sort((param1, param2) => param1.paramIndex - param2.paramIndex);
-    const columnsNullability = columns.map(col => !col.is_nullable);
-    const multipleRowsResult = !isSingleRowResult(selectstmt, dbSchema);
+    const multipleRowsResult = !isSingleRowResult(selectstmt, context.dbSchema);
     const limit = checkLimit(selectstmt);
-    return {
+    const postgresTraverseResult = {
         queryType: 'Select',
         multipleRowsResult,
-        columnsNullability,
+        columns,
         parametersNullability: traverseResult.parameters.map(param => param.isNotNull),
         parameterList: paramIsListResult,
         limit
     };
+    if (traverseResult.relations) {
+        postgresTraverseResult.relations = traverseResult.relations;
+    }
+    if (traverseResult.dynamicQueryInfo) {
+        postgresTraverseResult.dynamicQueryInfo = traverseResult.dynamicQueryInfo;
+    }
+    return postgresTraverseResult;
 }
-function traverse_selectstmt(selectstmt, dbSchema, fromColumns, traverseResult) {
+function traverse_selectstmt(selectstmt, context, traverseResult) {
     const select_no_parens = selectstmt.select_no_parens();
     if (select_no_parens) {
-        return traverse_select_no_parens(select_no_parens, dbSchema, fromColumns, traverseResult);
+        return traverse_select_no_parens(select_no_parens, context, traverseResult);
     }
     return [];
 }
-function traverse_select_no_parens(select_no_parens, dbSchema, fromColumns, traverseResult) {
+function traverse_select_no_parens(select_no_parens, context, traverseResult) {
     let withColumns = [];
     const with_clause = select_no_parens.with_clause();
     if (with_clause) {
         with_clause.cte_list().common_table_expr_list()
             .forEach(common_table_expr => {
-            const withResult = traverse_common_table_expr(common_table_expr, dbSchema, withColumns.concat(fromColumns), traverseResult);
+            const newContext = Object.assign(Object.assign({}, context), { fromColumns: withColumns.concat(context.fromColumns) });
+            const withResult = traverse_common_table_expr(common_table_expr, newContext, traverseResult);
             withColumns.push(...withResult);
         });
     }
     const select_clause = select_no_parens.select_clause();
-    if (select_clause) {
-        return traverse_select_clause(select_clause, dbSchema, withColumns.concat(fromColumns), traverseResult);
+    const newContext = Object.assign(Object.assign({}, context), { fromColumns: withColumns.concat(context.fromColumns) });
+    const selectResult = traverse_select_clause(select_clause, newContext, traverseResult);
+    const select_limit = select_no_parens.select_limit();
+    if (select_limit) {
+        const numParamsBefore = traverseResult.parameters.length;
+        const limit_clause = select_limit.limit_clause();
+        const limit_a_expr = limit_clause.select_limit_value().a_expr();
+        traverse_a_expr(limit_a_expr, context, traverseResult);
+        let fragment = '';
+        if (limit_clause) {
+            if (context.collectDynamicQueryInfo) {
+                fragment += (0, select_columns_1.extractOriginalSql)(limit_clause);
+            }
+        }
+        const offset_clause = select_limit.offset_clause();
+        if (offset_clause) {
+            const offset_a_expr = offset_clause.select_offset_value().a_expr();
+            traverse_a_expr(offset_a_expr, context, traverseResult);
+            if (context.collectDynamicQueryInfo) {
+                fragment += ' ' + (0, select_columns_1.extractOriginalSql)(offset_clause);
+            }
+        }
+        if (fragment) {
+            const parameters = traverseResult.parameters.slice(numParamsBefore).map((_, index) => index + numParamsBefore);
+            traverseResult.dynamicQueryInfo.limitOffset = {
+                fragment,
+                parameters
+            };
+        }
     }
-    return [];
+    return selectResult;
 }
-function traverse_common_table_expr(common_table_expr, dbSchema, fromColumns, traverseResult) {
+function traverse_common_table_expr(common_table_expr, context, traverseResult) {
+    var _a;
     const tableName = common_table_expr.name().getText();
     const select_stmt = common_table_expr.preparablestmt().selectstmt();
-    if (select_stmt) {
-        const columns = traverse_selectstmt(select_stmt, dbSchema, fromColumns, traverseResult);
-        const columnsWithTalbeName = columns.map(col => (Object.assign(Object.assign({}, col), { table_name: tableName })));
-        return columnsWithTalbeName;
+    const numParamsBefore = traverseResult.parameters.length;
+    const columns = traverse_selectstmt(select_stmt, Object.assign(Object.assign({}, context), { collectDynamicQueryInfo: false }), traverseResult);
+    const columnsWithTalbeName = columns.map(col => (Object.assign(Object.assign({}, col), { table_name: tableName })));
+    if (context.collectDynamicQueryInfo) {
+        const parameters = traverseResult.parameters.slice(numParamsBefore).map((_, index) => index + numParamsBefore);
+        (_a = traverseResult.dynamicQueryInfo) === null || _a === void 0 ? void 0 : _a.with.push({
+            fragment: (0, select_columns_1.extractOriginalSql)(common_table_expr),
+            relationName: tableName,
+            parameters
+        });
     }
-    return [];
+    return columnsWithTalbeName;
 }
-function traverse_select_clause(select_clause, dbSchema, fromColumns, traverseResult) {
+function traverse_select_clause(select_clause, context, traverseResult) {
     const simple_select_intersect_list = select_clause.simple_select_intersect_list();
     let selectColumns = [];
     if (simple_select_intersect_list) {
-        selectColumns = traverse_simple_select_intersect(simple_select_intersect_list[0], dbSchema, fromColumns, traverseResult);
+        selectColumns = traverse_simple_select_intersect(simple_select_intersect_list[0], context, traverseResult);
     }
     //union
     for (let index = 1; index < simple_select_intersect_list.length; index++) {
-        const unionNotNull = traverse_simple_select_intersect(simple_select_intersect_list[index], dbSchema, fromColumns, traverseResult);
+        const unionNotNull = traverse_simple_select_intersect(simple_select_intersect_list[index], context, traverseResult);
         selectColumns = selectColumns.map((value, columnIndex) => {
-            const col = Object.assign(Object.assign({}, value), { is_nullable: value.is_nullable || unionNotNull[columnIndex].is_nullable });
+            const col = {
+                column_name: value.column_name,
+                is_nullable: value.is_nullable || unionNotNull[columnIndex].is_nullable,
+                table_name: '',
+                table_schema: ''
+            };
             return col;
         });
     }
     return selectColumns;
 }
-function traverse_simple_select_intersect(simple_select_intersect, dbSchema, fromColumns, traverseResult) {
+function traverse_simple_select_intersect(simple_select_intersect, context, traverseResult) {
     const simple_select_pramary = simple_select_intersect.simple_select_pramary_list()[0];
     if (simple_select_pramary) {
-        return traverse_simple_select_pramary(simple_select_pramary, dbSchema, fromColumns, traverseResult);
+        return traverse_simple_select_pramary(simple_select_pramary, context, traverseResult);
     }
     return [];
 }
-function traverse_simple_select_pramary(simple_select_pramary, dbSchema, parentFromColumns, traverseResult) {
-    var _a;
+function traverse_simple_select_pramary(simple_select_pramary, context, traverseResult) {
+    var _a, _b;
     const fromColumns = [];
     const from_clause = simple_select_pramary.from_clause();
     if (from_clause) {
         const where_clause = simple_select_pramary.where_clause();
-        const fields = traverse_from_clause(from_clause, dbSchema, parentFromColumns, traverseResult);
+        const fields = traverse_from_clause(from_clause, context, traverseResult);
         const fieldsNotNull = where_clause != null ? fields.map(field => checkIsNullable(where_clause, field)) : fields;
         fromColumns.push(...fieldsNotNull);
     }
     const values_clause = simple_select_pramary.values_clause();
     if (values_clause) {
-        const valuesColumns = traverse_values_clause(values_clause, dbSchema, parentFromColumns, traverseResult);
+        const valuesColumns = traverse_values_clause(values_clause, context, traverseResult);
         return valuesColumns;
     }
     const where_a_expr = (_a = simple_select_pramary.where_clause()) === null || _a === void 0 ? void 0 : _a.a_expr();
+    //fromColumns has precedence
+    const newContext = Object.assign(Object.assign({}, context), { fromColumns: fromColumns.concat(context.fromColumns) });
     if (where_a_expr) {
-        traverse_a_expr(where_a_expr, dbSchema, parentFromColumns.concat(fromColumns), traverseResult);
+        const numParamsBefore = traverseResult.parameters.length;
+        traverse_a_expr(where_a_expr, newContext, traverseResult);
+        if (context.collectDynamicQueryInfo) {
+            const parameters = traverseResult.parameters.slice(numParamsBefore).map((_, index) => index + numParamsBefore);
+            const relations = extractRelations(where_a_expr);
+            (_b = traverseResult.dynamicQueryInfo) === null || _b === void 0 ? void 0 : _b.where.push({
+                fragment: `AND ${(0, select_columns_1.extractOriginalSql)(where_a_expr)}`,
+                parameters,
+                dependOnRelations: relations
+            });
+        }
     }
-    const filteredColumns = filterColumns_simple_select_pramary(simple_select_pramary, dbSchema, parentFromColumns.concat(fromColumns), traverseResult);
+    const filteredColumns = filterColumns_simple_select_pramary(simple_select_pramary, newContext, traverseResult);
     return filteredColumns;
 }
-function traverse_values_clause(values_clause, dbSchema, fromColumns, traverseResult) {
+function extractRelations(a_expr) {
+    const columnsRef = collectContextsOfType(a_expr, PostgreSQLParser_1.ColumnrefContext);
+    const relations = columnsRef
+        .map((colRefExpr) => {
+        const colRef = colRefExpr;
+        const tableName = (0, select_columns_1.splitName)(colRef.getText());
+        return tableName;
+    });
+    const uniqueRelations = [...new Set(relations.map(relation => relation.prefix))];
+    return uniqueRelations;
+}
+function traverse_values_clause(values_clause, context, traverseResult) {
     const expr_list_list = values_clause.expr_list_list();
     if (expr_list_list) {
-        return expr_list_list.flatMap(expr_list => traverse_expr_list(expr_list, dbSchema, fromColumns, traverseResult));
+        return expr_list_list.flatMap(expr_list => traverse_expr_list(expr_list, context, traverseResult));
     }
     return [];
 }
-function traverse_expr_list(expr_list, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_list(expr_list, context, traverseResult) {
     const columns = expr_list.a_expr_list().map(a_expr => {
-        const notNull = traverse_a_expr(a_expr, dbSchema, fromColumns, traverseResult);
+        const notNull = traverse_a_expr(a_expr, context, traverseResult);
         const result = {
-            column_name: a_expr.getText(),
+            column_name: '?column?',
             is_nullable: !notNull,
             table_name: '',
             table_schema: ''
@@ -158,234 +253,307 @@ function traverse_expr_list(expr_list, dbSchema, fromColumns, traverseResult) {
     });
     return columns;
 }
-function filterColumns_simple_select_pramary(simple_select_pramary, dbSchema, fromColumns, traverseResult) {
+function filterColumns_simple_select_pramary(simple_select_pramary, context, traverseResult) {
     const target_list_ = simple_select_pramary.target_list_();
     if (target_list_) {
         const target_list = target_list_.target_list();
         if (target_list) {
-            return traverse_target_list(target_list, dbSchema, fromColumns, traverseResult);
+            return traverse_target_list(target_list, context, traverseResult);
         }
     }
     const target_list = simple_select_pramary.target_list();
     if (target_list) {
-        return traverse_target_list(target_list, dbSchema, fromColumns, traverseResult);
+        return traverse_target_list(target_list, context, traverseResult);
     }
     return [];
 }
-function traverse_target_list(target_list, dbSchema, fromColumns, traverseResult) {
+function traverse_target_list(target_list, context, traverseResult) {
     const columns = target_list.target_el_list().flatMap(target_el => {
         const fieldName = (0, select_columns_1.splitName)(target_el.getText());
         if (fieldName.name == '*') {
-            const columns = filterColumns(fromColumns, fieldName);
+            const columns = filterColumns(context.fromColumns, fieldName);
+            if (context.collectDynamicQueryInfo) {
+                columns.forEach(col => {
+                    var _a;
+                    (_a = traverseResult.dynamicQueryInfo) === null || _a === void 0 ? void 0 : _a.select.push({
+                        fragment: `${col.table_name}.${col.column_name}`,
+                        fragmentWitoutAlias: `${col.table_name}.${col.column_name}`,
+                        dependOnRelations: [col.table_name],
+                        parameters: []
+                    });
+                });
+            }
             return columns;
         }
-        const column = isNotNull_target_el(target_el, dbSchema, fromColumns, traverseResult);
+        const column = traverse_target_el(target_el, context, traverseResult);
         return [column];
     });
     return columns;
 }
-function isNotNull_target_el(target_el, dbSchema, fromColumns, traverseResult) {
+function traverse_target_el(target_el, context, traverseResult) {
+    var _a, _b;
     if (target_el instanceof PostgreSQLParser_1.Target_labelContext) {
         const a_expr = target_el.a_expr();
-        const exprResult = traverse_a_expr(a_expr, dbSchema, fromColumns, traverseResult);
+        const numParamsBefore = traverseResult.parameters.length;
+        const exprResult = traverse_a_expr(a_expr, context, traverseResult);
         const colLabel = target_el.colLabel();
         const alias = colLabel != null ? colLabel.getText() : '';
-        const fieldName = (0, select_columns_1.splitName)(a_expr.getText());
+        if (alias) {
+            (_a = traverseResult.relations) === null || _a === void 0 ? void 0 : _a.forEach(relation => {
+                if ((relation.name === exprResult.table_name || relation.alias === exprResult.table_name)
+                    && relation.joinColumn === exprResult.column_name) {
+                    relation.joinColumn = alias;
+                }
+            });
+        }
+        if (context.collectDynamicQueryInfo) {
+            const parameters = traverseResult.parameters.slice(numParamsBefore).map((_, index) => index + numParamsBefore);
+            const relations = extractRelations(target_el.a_expr());
+            (_b = traverseResult.dynamicQueryInfo) === null || _b === void 0 ? void 0 : _b.select.push({
+                fragment: (0, select_columns_1.extractOriginalSql)(target_el),
+                fragmentWitoutAlias: (0, select_columns_1.extractOriginalSql)(target_el.a_expr()),
+                dependOnRelations: relations,
+                parameters
+            });
+        }
         return {
-            column_name: alias || fieldName.name,
+            column_name: alias || exprResult.column_name,
             is_nullable: exprResult.is_nullable,
-            table_name: fieldName.prefix,
-            table_schema: ''
+            table_name: exprResult.table_name,
+            table_schema: exprResult.table_schema
         };
     }
     throw Error('Column not found');
 }
-function traverse_a_expr(a_expr, dbSchema, fromColumns, traverseResult) {
+function traverse_a_expr(a_expr, context, traverseResult) {
     const a_expr_qual = a_expr.a_expr_qual();
     if (a_expr_qual) {
-        const notNull = traverse_a_expr_qual(a_expr_qual, dbSchema, fromColumns, traverseResult);
+        const notNull = traverse_a_expr_qual(a_expr_qual, context, traverseResult);
         return notNull;
     }
     return {
         column_name: '',
-        is_nullable: true
+        is_nullable: true,
+        table_name: '',
+        table_schema: ''
     };
 }
-function traverse_a_expr_qual(a_expr_qual, dbSchema, fromColumns, traverseResult) {
+function traverse_a_expr_qual(a_expr_qual, context, traverseResult) {
     const a_expr_lessless = a_expr_qual.a_expr_lessless();
     if (a_expr_lessless) {
-        return traverse_a_expr_lessless(a_expr_lessless, dbSchema, fromColumns, traverseResult);
+        return traverse_a_expr_lessless(a_expr_lessless, context, traverseResult);
     }
     throw Error('traverse_a_expr_qual -  Not expected:' + a_expr_qual.getText());
 }
-function traverse_a_expr_lessless(a_expr_lessless, dbSchema, fromColumns, traverseResult) {
+function traverse_a_expr_lessless(a_expr_lessless, context, traverseResult) {
     const a_expr_or = a_expr_lessless.a_expr_or_list()[0];
     if (a_expr_or) {
-        return traverse_expr_or(a_expr_or, dbSchema, fromColumns, traverseResult);
+        return traverse_expr_or(a_expr_or, context, traverseResult);
     }
     throw Error('traverse_a_expr_lessless -  Not expected:' + a_expr_lessless.getText());
 }
-function traverse_expr_or(a_expr_or, dbSchema, fromColumns, traverseResult) {
-    const a_expr_and = a_expr_or.a_expr_and_list()[0];
-    if (a_expr_and) {
-        return traverse_expr_and(a_expr_and, dbSchema, fromColumns, traverseResult);
+function traverse_expr_or(a_expr_or, context, traverseResult) {
+    // expr1 OR expr2
+    const result = a_expr_or.a_expr_and_list().map(a_expr_and => traverse_expr_and(a_expr_and, context, traverseResult));
+    if (result.length === 1) {
+        return result[0];
     }
-    throw Error('traverse_expr_or -  Not expected:' + a_expr_or.getText());
+    return {
+        column_name: '?column?',
+        is_nullable: result.some(col => col.is_nullable),
+        table_name: '',
+        table_schema: ''
+    };
 }
-function traverse_expr_and(a_expr_and, dbSchema, fromColumns, traverseResult) {
-    const result = a_expr_and.a_expr_between_list().map(a_expr_between => traverse_expr_between(a_expr_between, dbSchema, fromColumns, traverseResult));
+function traverse_expr_and(a_expr_and, context, traverseResult) {
+    const result = a_expr_and.a_expr_between_list().map(a_expr_between => traverse_expr_between(a_expr_between, context, traverseResult));
+    if (result.length === 1) {
+        return result[0];
+    }
     return {
-        column_name: a_expr_and.getText(),
-        is_nullable: result.some(col => col.is_nullable)
+        column_name: '?column?',
+        is_nullable: result.some(col => col.is_nullable),
+        table_name: '',
+        table_schema: ''
     };
 }
-function traverse_expr_between(a_expr_between, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_between(a_expr_between, context, traverseResult) {
     const a_expr_in = a_expr_between.a_expr_in_list()[0];
     if (a_expr_in) {
-        return traverse_expr_in(a_expr_in, dbSchema, fromColumns, traverseResult);
+        return traverse_expr_in(a_expr_in, context, traverseResult);
     }
     throw Error('traverse_expr_between -  Not expected:' + a_expr_between.getText());
 }
-function traverse_expr_in(a_expr_in, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_in(a_expr_in, context, traverseResult) {
     const a_expr_unary = a_expr_in.a_expr_unary_not();
     let leftExprResult = undefined;
     if (a_expr_unary) {
-        leftExprResult = traverse_expr_unary(a_expr_unary, dbSchema, fromColumns, traverseResult);
+        leftExprResult = traverse_expr_unary(a_expr_unary, context, traverseResult);
     }
     const in_expr = a_expr_in.in_expr();
     if (in_expr) {
-        traverse_in_expr(in_expr, dbSchema, fromColumns, traverseResult);
+        traverse_in_expr(in_expr, context, traverseResult);
+    }
+    if (in_expr === null && leftExprResult != null) {
+        return leftExprResult;
     }
     return {
         column_name: a_expr_in.getText(),
         //id in (...)  -> is_nullable: false
         // value -> is_nullable = leftExprResult.is_nullable
-        is_nullable: in_expr != null ? false : leftExprResult.is_nullable
+        is_nullable: in_expr != null ? false : leftExprResult.is_nullable,
+        table_name: '',
+        table_schema: ''
     };
 }
-function traverse_in_expr(in_expr, dbSchema, fromColumns, traverseResult) {
+function traverse_in_expr(in_expr, context, traverseResult) {
     if (in_expr instanceof PostgreSQLParser_1.In_expr_selectContext) {
         const select_with_parens = in_expr.select_with_parens();
-        traverse_select_with_parens(select_with_parens, dbSchema, fromColumns, traverseResult);
+        traverse_select_with_parens(select_with_parens, context, traverseResult);
     }
     if (in_expr instanceof PostgreSQLParser_1.In_expr_listContext) {
         in_expr.expr_list().a_expr_list().forEach(a_expr => {
-            traverse_a_expr(a_expr, dbSchema, fromColumns, traverseResult);
+            traverse_a_expr(a_expr, context, traverseResult);
         });
     }
 }
-function traverse_expr_unary(a_expr_unary, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_unary(a_expr_unary, context, traverseResult) {
     const a_expr_isnull = a_expr_unary.a_expr_isnull();
     if (a_expr_isnull) {
-        return traverse_expr_isnull(a_expr_isnull, dbSchema, fromColumns, traverseResult);
+        return traverse_expr_isnull(a_expr_isnull, context, traverseResult);
     }
     throw Error('traverse_expr_unary -  Not expected:' + a_expr_unary.getText());
 }
-function traverse_expr_isnull(a_expr_isnull, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_isnull(a_expr_isnull, context, traverseResult) {
     const a_expr_is_not = a_expr_isnull.a_expr_is_not();
     if (a_expr_is_not) {
-        return traverse_expr_is_not(a_expr_is_not, dbSchema, fromColumns, traverseResult);
+        return traverse_expr_is_not(a_expr_is_not, context, traverseResult);
     }
     throw Error('traverse_expr_isnull -  Not expected:' + a_expr_isnull.getText());
 }
-function traverse_expr_is_not(a_expr_is_not, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_is_not(a_expr_is_not, context, traverseResult) {
     const a_expr_compare = a_expr_is_not.a_expr_compare();
     if (a_expr_compare) {
-        return traverse_expr_compare(a_expr_compare, dbSchema, fromColumns, traverseResult);
+        return traverse_expr_compare(a_expr_compare, context, traverseResult);
     }
     throw Error('traverse_expr_is_not -  Not expected:' + a_expr_is_not.getText());
 }
-function traverse_expr_compare(a_expr_compare, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_compare(a_expr_compare, context, traverseResult) {
     const a_expr_like_list = a_expr_compare.a_expr_like_list();
     if (a_expr_like_list) {
-        const result = a_expr_like_list.map(a_expr_like => traverse_expr_like(a_expr_like, dbSchema, fromColumns, traverseResult));
+        const result = a_expr_like_list.map(a_expr_like => traverse_expr_like(a_expr_like, context, traverseResult));
+        if (result.length === 1) {
+            return result[0];
+        }
         return {
-            column_name: a_expr_compare.getText(),
-            is_nullable: result.some(col => col.is_nullable)
+            column_name: '?column?',
+            is_nullable: result.some(col => col.is_nullable),
+            table_name: '',
+            table_schema: ''
         };
     }
     throw Error('traverse_expr_compare -  Not expected:' + a_expr_compare.getText());
 }
-function traverse_expr_like(a_expr_like, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_like(a_expr_like, context, traverseResult) {
     const a_expr_qual_op_list = a_expr_like.a_expr_qual_op_list();
     if (a_expr_qual_op_list) {
-        const result = a_expr_qual_op_list.map(a_expr_qual_op => traverse_expr_qual_op(a_expr_qual_op, dbSchema, fromColumns, traverseResult));
+        const result = a_expr_qual_op_list.map(a_expr_qual_op => traverse_expr_qual_op(a_expr_qual_op, context, traverseResult));
+        if (result.length === 1) {
+            return result[0];
+        }
         return {
-            column_name: a_expr_like.getText(),
-            is_nullable: result.some(col => col.is_nullable)
+            column_name: '?column?',
+            is_nullable: result.some(col => col.is_nullable),
+            table_name: '',
+            table_schema: ''
         };
     }
     throw Error('traverse_expr_like -  Not expected:' + a_expr_like.getText());
 }
-function traverse_expr_qual_op(a_expr_qual_op, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_qual_op(a_expr_qual_op, context, traverseResult) {
     const a_expr_unary_qualop = a_expr_qual_op.a_expr_unary_qualop_list()[0];
     if (a_expr_unary_qualop) {
-        return traverse_expr_unary_qualop(a_expr_unary_qualop, dbSchema, fromColumns, traverseResult);
+        return traverse_expr_unary_qualop(a_expr_unary_qualop, context, traverseResult);
     }
     throw Error('traverse_expr_qual_op -  Not expected:' + a_expr_qual_op.getText());
 }
-function traverse_expr_unary_qualop(a_expr_unary_qualop, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_unary_qualop(a_expr_unary_qualop, context, traverseResult) {
     const a_expr_add = a_expr_unary_qualop.a_expr_add();
     if (a_expr_add) {
-        const exprResult = a_expr_add.a_expr_mul_list().map(a_expr_mul => traverse_expr_mul(a_expr_mul, dbSchema, fromColumns, traverseResult));
+        const exprResult = a_expr_add.a_expr_mul_list().map(a_expr_mul => traverse_expr_mul(a_expr_mul, context, traverseResult));
+        if (exprResult.length === 1) {
+            return exprResult[0];
+        }
         const result = {
-            column_name: a_expr_unary_qualop.getText(),
-            is_nullable: exprResult.some(col => col.is_nullable)
+            column_name: '?column?',
+            is_nullable: exprResult.some(col => col.is_nullable),
+            table_name: '',
+            table_schema: ''
         };
         return result;
     }
     throw Error('traverse_expr_unary_qualop -  Not expected:' + a_expr_unary_qualop.getText());
 }
-function traverse_expr_mul(a_expr_mul, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_mul(a_expr_mul, context, traverseResult) {
     const a_expr_mul_list = a_expr_mul.a_expr_caret_list();
     if (a_expr_mul_list) {
-        const notNullInfo = a_expr_mul.a_expr_caret_list().map(a_expr_caret => traverse_expr_caret(a_expr_caret, dbSchema, fromColumns, traverseResult));
+        const notNullInfo = a_expr_mul.a_expr_caret_list().map(a_expr_caret => traverse_expr_caret(a_expr_caret, context, traverseResult));
+        if (notNullInfo.length === 1) {
+            return notNullInfo[0];
+        }
         const result = {
-            column_name: a_expr_mul.getText(),
-            is_nullable: notNullInfo.some(notNullInfo => notNullInfo.is_nullable)
+            column_name: '?column?',
+            is_nullable: notNullInfo.some(notNullInfo => notNullInfo.is_nullable),
+            table_name: '',
+            table_schema: ''
         };
         return result;
     }
     throw Error('traverse_expr_mul -  Not expected:' + a_expr_mul.getText());
 }
-function traverse_expr_caret(a_expr_caret, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_caret(a_expr_caret, context, traverseResult) {
     const a_expr_unary_sign_list = a_expr_caret.a_expr_unary_sign_list();
     if (a_expr_unary_sign_list) {
         const notNullInfo = a_expr_caret.a_expr_unary_sign_list()
-            .map(a_expr_unary_sign => traverse_expr_unary_sign(a_expr_unary_sign, dbSchema, fromColumns, traverseResult));
+            .map(a_expr_unary_sign => traverse_expr_unary_sign(a_expr_unary_sign, context, traverseResult));
+        if (notNullInfo.length === 1) {
+            return notNullInfo[0];
+        }
         const result = {
-            column_name: a_expr_caret.getText(),
-            is_nullable: notNullInfo.some(notNullInfo => notNullInfo.is_nullable)
+            column_name: '?column?',
+            is_nullable: notNullInfo.some(notNullInfo => notNullInfo.is_nullable),
+            table_name: '',
+            table_schema: ''
         };
         return result;
     }
     throw Error('traverse_expr_caret -  Not expected:' + a_expr_caret.getText());
 }
-function traverse_expr_unary_sign(a_expr_unary_sign, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_unary_sign(a_expr_unary_sign, context, traverseResult) {
     const a_expr_at_time_zone = a_expr_unary_sign.a_expr_at_time_zone();
     if (a_expr_at_time_zone) {
-        return traverse_expr_at_time_zone(a_expr_at_time_zone, dbSchema, fromColumns, traverseResult);
+        return traverse_expr_at_time_zone(a_expr_at_time_zone, context, traverseResult);
     }
     throw Error('traverse_expr_unary_sign -  Not expected:' + a_expr_unary_sign.getText());
 }
-function traverse_expr_at_time_zone(a_expr_at_time_zone, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_at_time_zone(a_expr_at_time_zone, context, traverseResult) {
     const a_expr_collate = a_expr_at_time_zone.a_expr_collate();
     if (a_expr_collate) {
-        return traverse_expr_collate(a_expr_collate, dbSchema, fromColumns, traverseResult);
+        return traverse_expr_collate(a_expr_collate, context, traverseResult);
     }
     throw Error('traverse_expr_at_time_zone -  Not expected:' + a_expr_at_time_zone.getText());
 }
-function traverse_expr_collate(a_expr_collate, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_collate(a_expr_collate, context, traverseResult) {
     const a_expr_typecast = a_expr_collate.a_expr_typecast();
     if (a_expr_typecast) {
-        return traverse_expr_typecast(a_expr_typecast, dbSchema, fromColumns, traverseResult);
+        return traverse_expr_typecast(a_expr_typecast, context, traverseResult);
     }
     throw Error('traverse_expr_collate -  Not expected:' + a_expr_collate.getText());
 }
-function traverse_expr_typecast(a_expr_typecast, dbSchema, fromColumns, traverseResult) {
+function traverse_expr_typecast(a_expr_typecast, context, traverseResult) {
     const c_expr = a_expr_typecast.c_expr();
     if (c_expr) {
-        return traversec_expr(c_expr, dbSchema, fromColumns, traverseResult);
+        return traversec_expr(c_expr, context, traverseResult);
     }
     throw Error('traverse_expr_typecast -  Not expected:' + a_expr_typecast.getText());
 }
@@ -394,12 +562,12 @@ function traverseColumnRef(columnref, fromColumns) {
     const col = findColumn(fieldName, fromColumns);
     return col;
 }
-function traversec_expr(c_expr, dbSchema, fromColumns, traverseResult) {
-    var _a, _b;
+function traversec_expr(c_expr, context, traverseResult) {
+    var _a, _b, _c, _d, _e;
     if (c_expr instanceof PostgreSQLParser_1.C_expr_exprContext) {
         const columnref = c_expr.columnref();
         if (columnref) {
-            const col = traverseColumnRef(columnref, fromColumns);
+            const col = traverseColumnRef(columnref, context.fromColumns);
             return col;
         }
         const aexprconst = c_expr.aexprconst();
@@ -407,67 +575,111 @@ function traversec_expr(c_expr, dbSchema, fromColumns, traverseResult) {
             const is_nullable = aexprconst.NULL_P() != null;
             return {
                 column_name: aexprconst.getText(),
-                is_nullable
+                is_nullable,
+                table_name: '',
+                table_schema: ''
             };
         }
         if (c_expr.PARAM()) {
             traverseResult.parameters.push({
                 paramIndex: c_expr.start.start,
-                isNotNull: true
+                isNotNull: !context.propagatesNull
             });
             return {
                 column_name: c_expr.PARAM().getText(),
-                is_nullable: false
+                is_nullable: !!context.propagatesNull,
+                table_name: '',
+                table_schema: ''
             };
         }
         const func_application = (_a = c_expr.func_expr()) === null || _a === void 0 ? void 0 : _a.func_application();
         if (func_application) {
-            const isNotNull = traversefunc_application(func_application, dbSchema, fromColumns, traverseResult);
+            const isNotNull = traversefunc_application(func_application, context, traverseResult);
             return {
-                column_name: func_application.getText(),
-                is_nullable: !isNotNull
+                column_name: ((_b = func_application.func_name()) === null || _b === void 0 ? void 0 : _b.getText()) || func_application.getText(),
+                is_nullable: !isNotNull,
+                table_name: '',
+                table_schema: ''
             };
         }
-        const func_expr_common_subexpr = (_b = c_expr.func_expr()) === null || _b === void 0 ? void 0 : _b.func_expr_common_subexpr();
+        const func_expr_common_subexpr = (_c = c_expr.func_expr()) === null || _c === void 0 ? void 0 : _c.func_expr_common_subexpr();
         if (func_expr_common_subexpr) {
-            const isNotNull = traversefunc_expr_common_subexpr(func_expr_common_subexpr, dbSchema, fromColumns, traverseResult);
+            const isNotNull = traversefunc_expr_common_subexpr(func_expr_common_subexpr, context, traverseResult);
             return {
-                column_name: func_expr_common_subexpr.getText(),
-                is_nullable: !isNotNull
+                column_name: ((_e = (_d = func_expr_common_subexpr.getText().split('(')) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.trim()) || func_expr_common_subexpr.getText(),
+                is_nullable: !isNotNull,
+                table_name: '',
+                table_schema: ''
             };
         }
         const select_with_parens = c_expr.select_with_parens();
         if (select_with_parens) {
-            traverse_select_with_parens(select_with_parens, dbSchema, fromColumns, traverseResult);
+            traverse_select_with_parens(select_with_parens, context, traverseResult);
             return {
-                column_name: select_with_parens.getText(),
-                is_nullable: true
+                column_name: '?column?',
+                is_nullable: true,
+                table_name: '',
+                table_schema: ''
             };
         }
         const a_expr_in_parens = c_expr._a_expr_in_parens;
         if (a_expr_in_parens) {
-            return traverse_a_expr(a_expr_in_parens, dbSchema, fromColumns, traverseResult);
+            return traverse_a_expr(a_expr_in_parens, context, traverseResult);
+        }
+        const explicit_row = c_expr.explicit_row();
+        if (explicit_row) {
+            const expr_list = explicit_row.expr_list().a_expr_list()
+                .map(a_expr => traverse_a_expr(a_expr, context, traverseResult));
+            return {
+                column_name: '?column?',
+                is_nullable: expr_list.some(col => col.is_nullable),
+                table_name: '',
+                table_schema: ''
+            };
+        }
+        const implicit_row = c_expr.implicit_row();
+        if (implicit_row) {
+            const expr_list = implicit_row.expr_list().a_expr_list().concat(implicit_row.a_expr())
+                .map(a_expr => traverse_a_expr(a_expr, context, traverseResult));
+            return {
+                column_name: '?column?',
+                is_nullable: expr_list.some(col => col.is_nullable),
+                table_name: '',
+                table_schema: ''
+            };
         }
     }
     if (c_expr instanceof PostgreSQLParser_1.C_expr_caseContext) {
-        const isNotNull = traversec_expr_case(c_expr, dbSchema, fromColumns, traverseResult);
+        const isNotNull = traversec_expr_case(c_expr, context, traverseResult);
         return {
-            column_name: c_expr.getText(),
-            is_nullable: !isNotNull
+            column_name: '?column?',
+            is_nullable: !isNotNull,
+            table_name: '',
+            table_schema: ''
         };
     }
     if (c_expr instanceof PostgreSQLParser_1.C_expr_existsContext) {
         //todo - traverse
         return {
-            column_name: c_expr.getText(),
-            is_nullable: false
+            column_name: '?column?',
+            is_nullable: false,
+            table_name: '',
+            table_schema: ''
         };
     }
     throw Error('traversec_expr -  Not expected:' + c_expr.getText());
 }
 function filterColumns(fromColumns, fieldName) {
     return fromColumns.filter(col => (fieldName.prefix === '' || col.table_name === fieldName.prefix)
-        && (fieldName.name === '*' || col.column_name === fieldName.name));
+        && (fieldName.name === '*' || col.column_name === fieldName.name)).map(col => {
+        const result = {
+            column_name: col.column_name,
+            is_nullable: col.is_nullable,
+            table_name: col.table_name,
+            table_schema: col.table_schema
+        };
+        return result;
+    });
 }
 function excludeColumns(fromColumns, excludeList) {
     return fromColumns.filter(col => {
@@ -476,21 +688,21 @@ function excludeColumns(fromColumns, excludeList) {
         return !found;
     });
 }
-function traversec_expr_case(c_expr_case, dbSchema, fromColumns, traverseResult) {
+function traversec_expr_case(c_expr_case, context, traverseResult) {
     var _a;
     const case_expr = c_expr_case.case_expr();
-    const whenResult = case_expr.when_clause_list().when_clause_list().map(when_clause => traversewhen_clause(when_clause, dbSchema, fromColumns, traverseResult));
+    const whenResult = case_expr.when_clause_list().when_clause_list().map(when_clause => traversewhen_clause(when_clause, context, traverseResult));
     const whenIsNotNull = whenResult.every(when => when);
     const elseExpr = (_a = case_expr.case_default()) === null || _a === void 0 ? void 0 : _a.a_expr();
-    const elseIsNotNull = elseExpr ? !traverse_a_expr(elseExpr, dbSchema, fromColumns, traverseResult).is_nullable : false;
+    const elseIsNotNull = elseExpr ? !traverse_a_expr(elseExpr, context, traverseResult).is_nullable : false;
     return elseIsNotNull && whenIsNotNull;
 }
-function traversewhen_clause(when_clause, dbSchema, fromColumns, traverseResult) {
+function traversewhen_clause(when_clause, context, traverseResult) {
     const a_expr_list = when_clause.a_expr_list();
     const [whenExprList, thenExprList] = partition(a_expr_list, (index) => index % 2 === 0);
     const whenExprResult = thenExprList.map((thenExpr, index) => {
-        traverse_a_expr(whenExprList[index], dbSchema, fromColumns, traverseResult);
-        const thenExprResult = traverse_a_expr(thenExpr, dbSchema, fromColumns, traverseResult);
+        traverse_a_expr(whenExprList[index], context, traverseResult);
+        const thenExprResult = traverse_a_expr(thenExpr, context, traverseResult);
         return thenExprResult;
     });
     return whenExprResult.every(res => res);
@@ -506,11 +718,11 @@ function partition(array, predicate) {
         return acc;
     }, [[], []]);
 }
-function traversefunc_application(func_application, dbSchema, fromColumns, traverseResult) {
+function traversefunc_application(func_application, context, traverseResult) {
     var _a;
     const functionName = func_application.func_name().getText().toLowerCase();
     const func_arg_expr_list = ((_a = func_application.func_arg_list()) === null || _a === void 0 ? void 0 : _a.func_arg_expr_list()) || [];
-    const argsResult = func_arg_expr_list.map(func_arg_expr => traversefunc_arg_expr(func_arg_expr, dbSchema, fromColumns, traverseResult));
+    const argsResult = func_arg_expr_list.map(func_arg_expr => traversefunc_arg_expr(func_arg_expr, context, traverseResult));
     if (functionName === 'count') {
         return true;
     }
@@ -527,34 +739,27 @@ function traversefunc_application(func_application, dbSchema, fromColumns, trave
     if (functionName === 'generate_series') {
         return true;
     }
-    if (func_arg_expr_list) {
-        func_arg_expr_list.forEach(func_arg_expr => traversefunc_arg_expr(func_arg_expr, dbSchema, fromColumns, traverseResult));
-    }
     return false;
 }
-function traversefunc_expr_common_subexpr(func_expr_common_subexpr, dbSchema, fromColumns, traverseResult) {
-    if (func_expr_common_subexpr.COALESCE()) {
+function traversefunc_expr_common_subexpr(func_expr_common_subexpr, context, traverseResult) {
+    if (func_expr_common_subexpr.COALESCE() || func_expr_common_subexpr.GREATEST() || func_expr_common_subexpr.LEAST()) {
         const func_arg_list = func_expr_common_subexpr.expr_list().a_expr_list();
         const result = func_arg_list.map(func_arg_expr => {
-            const paramResult = traverse_a_expr(func_arg_expr, dbSchema, fromColumns, traverseResult);
-            if (isParameter(paramResult.column_name)) {
-                traverseResult.parameters[traverseResult.parameters.length - 1].isNotNull = false;
-                paramResult.is_nullable = true;
-            }
+            const paramResult = traverse_a_expr(func_arg_expr, Object.assign(Object.assign({}, context), { propagatesNull: true }), traverseResult);
             return paramResult;
         });
         return result.some(col => !col.is_nullable);
     }
     if (func_expr_common_subexpr.EXTRACT()) {
         const a_expr = func_expr_common_subexpr.extract_list().a_expr();
-        const result = traverse_a_expr(a_expr, dbSchema, fromColumns, traverseResult);
+        const result = traverse_a_expr(a_expr, context, traverseResult);
         return !result.is_nullable;
     }
     return false;
 }
-function traversefunc_arg_expr(func_arg_expr, dbSchema, fromColumns, traverseResult) {
+function traversefunc_arg_expr(func_arg_expr, context, traverseResult) {
     const a_expr = func_arg_expr.a_expr();
-    return !traverse_a_expr(a_expr, dbSchema, fromColumns, traverseResult).is_nullable;
+    return !traverse_a_expr(a_expr, context, traverseResult).is_nullable;
 }
 function findColumn(fieldName, fromColumns) {
     const col = fromColumns.find(col => (fieldName.prefix === '' || col.table_name.toLowerCase() === fieldName.prefix.toLowerCase()) && col.column_name.toLowerCase() === fieldName.name.toLowerCase());
@@ -571,65 +776,147 @@ function checkIsNullable(where_clause, field) {
     const col = Object.assign(Object.assign({}, field), { is_nullable: !isNotNullResult });
     return col;
 }
-function traverse_from_clause(from_clause, dbSchema, fromColumns, traverseResult) {
+function traverse_from_clause(from_clause, context, traverseResult) {
     const from_list = from_clause.from_list();
     if (from_list) {
-        return traverse_from_list(from_list, dbSchema, fromColumns, traverseResult);
+        return traverse_from_list(from_list, context, traverseResult);
     }
     return [];
 }
-function traverse_from_list(from_list, dbSchema, fromColumns, traverseResult) {
-    const newColumns = from_list.table_ref_list().flatMap(table_ref => traverse_table_ref(table_ref, dbSchema, fromColumns, traverseResult));
+function traverse_from_list(from_list, context, traverseResult) {
+    const newColumns = from_list.table_ref_list().flatMap(table_ref => traverse_table_ref(table_ref, context, traverseResult));
     return newColumns;
 }
-function traverse_table_ref(table_ref, dbSchema, fromColumns, traverseResult) {
+function traverse_table_ref(table_ref, context, traverseResult) {
+    var _a, _b;
+    const { fromColumns, dbSchema } = context;
     const allColumns = [];
     const relation_expr = table_ref.relation_expr();
     const aliasClause = table_ref.alias_clause();
-    const alias = aliasClause ? aliasClause.colid().getText() : undefined;
+    const alias = aliasClause ? aliasClause.colid().getText() : '';
     if (relation_expr) {
         const tableName = traverse_relation_expr(relation_expr, dbSchema);
         const tableNameWithAlias = alias ? alias : tableName.name;
-        const fromColumnsResult = fromColumns.concat(dbSchema).filter(col => col.table_name === tableName.name).map(col => (Object.assign(Object.assign({}, col), { table_name: tableNameWithAlias })));
+        const fromColumnsResult = fromColumns.concat(dbSchema).filter(col => col.table_name === tableName.name)
+            .map(col => (Object.assign(Object.assign({}, col), { table_name: tableNameWithAlias })));
         allColumns.push(...fromColumnsResult);
-    }
-    const table_ref_list = table_ref.table_ref_list();
-    const join_type_list = table_ref.join_type_list();
-    const join_qual_list = table_ref.join_qual_list();
-    if (table_ref_list) {
-        const joinColumns = table_ref_list.flatMap((table_ref, joinIndex) => {
-            const joinType = join_type_list[joinIndex]; //INNER, LEFT
-            const joinQual = join_qual_list[joinIndex];
-            const joinColumns = traverse_table_ref(table_ref, dbSchema, fromColumns, traverseResult);
-            const isUsing = (joinQual === null || joinQual === void 0 ? void 0 : joinQual.USING()) ? true : false;
-            const isLeftJoin = joinType === null || joinType === void 0 ? void 0 : joinType.LEFT();
-            const filteredColumns = isUsing ? filterUsingColumns(joinColumns, joinQual) : joinColumns;
-            const resultColumns = isLeftJoin ? filteredColumns.map(col => (Object.assign(Object.assign({}, col), { is_nullable: true }))) : filteredColumns;
-            return resultColumns;
-        });
-        allColumns.push(...joinColumns);
+        if (context.collectNestedInfo) {
+            const key = fromColumnsResult.filter(col => col.column_key === 'PRI');
+            const renameAs = (aliasClause === null || aliasClause === void 0 ? void 0 : aliasClause.AS()) != null;
+            const relation = {
+                name: tableName.name,
+                alias: alias,
+                renameAs,
+                parentRelation: '',
+                joinColumn: ((_a = key[0]) === null || _a === void 0 ? void 0 : _a.column_name) || '',
+                cardinality: 'one',
+                parentCardinality: 'one'
+            };
+            (_b = traverseResult.relations) === null || _b === void 0 ? void 0 : _b.push(relation);
+        }
+        const table_ref_list = table_ref.table_ref_list();
+        const join_type_list = table_ref.join_type_list();
+        const join_qual_list = table_ref.join_qual_list();
+        if (context.collectDynamicQueryInfo && traverseResult.dynamicQueryInfo.from.length == 0) {
+            collectDynamicQueryInfoTableRef(table_ref, null, null, fromColumnsResult, [], traverseResult);
+        }
+        if (table_ref_list) {
+            const joinColumns = table_ref_list.flatMap((table_ref, joinIndex) => {
+                const joinType = join_type_list[joinIndex]; //INNER, LEFT
+                const joinQual = join_qual_list[joinIndex];
+                const numParamsBefore = traverseResult.parameters.length;
+                const joinColumns = traverse_table_ref(table_ref, context, traverseResult);
+                const isUsing = (joinQual === null || joinQual === void 0 ? void 0 : joinQual.USING()) ? true : false;
+                const isLeftJoin = joinType === null || joinType === void 0 ? void 0 : joinType.LEFT();
+                const filteredColumns = isUsing ? filterUsingColumns(joinColumns, joinQual) : joinColumns;
+                const resultColumns = isLeftJoin ? filteredColumns.map(col => (Object.assign(Object.assign({}, col), { is_nullable: true }))) : filteredColumns;
+                if (context.collectNestedInfo) {
+                    collectNestedInfo(joinQual, resultColumns, traverseResult);
+                }
+                if (context.collectDynamicQueryInfo) {
+                    const parameters = traverseResult.parameters.slice(numParamsBefore).map((_, index) => index + numParamsBefore);
+                    collectDynamicQueryInfoTableRef(table_ref, joinType, joinQual, resultColumns, parameters, traverseResult);
+                }
+                return resultColumns;
+            });
+            allColumns.push(...joinColumns);
+        }
     }
     const select_with_parens = table_ref.select_with_parens();
     if (select_with_parens) {
-        const columns = traverse_select_with_parens(select_with_parens, dbSchema, fromColumns, traverseResult);
+        const columns = traverse_select_with_parens(select_with_parens, Object.assign(Object.assign({}, context), { collectDynamicQueryInfo: false }), traverseResult);
         const withAlias = columns.map(col => (Object.assign(Object.assign({}, col), { table_name: alias || col.table_name })));
         return withAlias;
     }
     return allColumns;
 }
+function collectDynamicQueryInfoTableRef(table_ref, joinType, joinQual, columns, parameters, traverseResult) {
+    var _a, _b;
+    const alias = table_ref.alias_clause() ? (0, select_columns_1.extractOriginalSql)(table_ref.alias_clause()) : '';
+    const fromExpr = (0, select_columns_1.extractOriginalSql)(table_ref.relation_expr() || table_ref.select_with_parens());
+    const tableName = ((_a = table_ref.relation_expr()) === null || _a === void 0 ? void 0 : _a.getText()) || alias;
+    const fromOrJoin = joinType ? `${(0, select_columns_1.extractOriginalSql)(joinType)} JOIN` : 'FROM';
+    const join = joinQual ? ` ${(0, select_columns_1.extractOriginalSql)(joinQual)}` : '';
+    const fromFragment = `${fromOrJoin} ${fromExpr} ${alias}${join}`;
+    const fields = columns.map(col => col.column_name);
+    const joinColumns = joinQual ? getJoinColumns(joinQual) : [];
+    const parentList = joinColumns.filter(joinRef => joinRef.prefix !== tableName && joinRef.prefix !== alias);
+    const parentRelation = parentList.length === 1 ? parentList[0].prefix : '';
+    (_b = traverseResult.dynamicQueryInfo) === null || _b === void 0 ? void 0 : _b.from.push({
+        fragment: fromFragment,
+        fields,
+        parameters,
+        relationName: tableName,
+        relationAlias: alias,
+        parentRelation
+    });
+}
+function getJoinColumns(joinQual) {
+    const a_expr_or_list = joinQual ? collectContextsOfType(joinQual, PostgreSQLParser_1.A_expr_orContext) : [];
+    if (a_expr_or_list.length == 1) {
+        const a_expr_or = a_expr_or_list[0];
+        const a_expr_and = a_expr_or.a_expr_and_list()[0];
+        const columnref = collectContextsOfType(a_expr_and, PostgreSQLParser_1.ColumnrefContext);
+        const joinColumns = columnref.map(colRef => (0, select_columns_1.splitName)(colRef.getText()));
+        return joinColumns;
+    }
+    return [];
+}
+function collectNestedInfo(joinQual, resultColumns, traverseResult) {
+    var _a;
+    const joinColumns = getJoinColumns(joinQual);
+    const currentRelation = (_a = traverseResult.relations) === null || _a === void 0 ? void 0 : _a.at(-1);
+    joinColumns.forEach(joinRef => {
+        if (currentRelation) {
+            const joinColumn = resultColumns.filter(col => col.column_name === joinRef.name)[0];
+            const unique = joinColumn && (joinColumn.column_key === 'PRI' || joinColumn.column_key === 'UNI');
+            if (joinRef.prefix === currentRelation.name || joinRef.prefix === currentRelation.alias) {
+                if (!unique) {
+                    currentRelation.cardinality = 'many';
+                }
+            }
+            else {
+                currentRelation.parentRelation = joinRef.prefix;
+                if (!unique) {
+                    currentRelation.parentCardinality = 'many';
+                }
+            }
+        }
+    });
+}
 function filterUsingColumns(fromColumns, joinQual) {
     const excludeList = joinQual.name_list().name_list().map(name => (0, select_columns_1.splitName)(name.getText()));
     const filteredColumns = excludeColumns(fromColumns, excludeList);
     return filteredColumns;
 }
-function traverse_select_with_parens(select_with_parens, dbSchema, fromColumns, traverseResult) {
+function traverse_select_with_parens(select_with_parens, context, traverseResult) {
     const select_with_parens2 = select_with_parens.select_with_parens();
     if (select_with_parens2) {
-        return traverse_select_with_parens(select_with_parens2, dbSchema, fromColumns, traverseResult);
+        return traverse_select_with_parens(select_with_parens2, context, traverseResult);
     }
     const select_no_parens = select_with_parens.select_no_parens();
     if (select_no_parens) {
-        return traverse_select_no_parens(select_no_parens, dbSchema, fromColumns, traverseResult);
+        return traverse_select_no_parens(select_no_parens, context, traverseResult);
     }
     return [];
 }
@@ -713,20 +1000,26 @@ function traverseInsertstmt(insertstmt, dbSchema) {
     const insertColumnsList = insert_rest.insert_column_list()
         .insert_column_item_list()
         .map(insert_column_item => traverse_insert_column_item(insert_column_item, insertColumns));
+    const context = {
+        dbSchema,
+        fromColumns: insertColumns,
+        collectNestedInfo: false,
+        collectDynamicQueryInfo: false
+    };
     const selectstmt = insert_rest.selectstmt();
-    traverse_insert_select_stmt(selectstmt, dbSchema, insertColumnsList, traverseResult);
+    traverse_insert_select_stmt(selectstmt, Object.assign(Object.assign({}, context), { fromColumns: insertColumnsList }), traverseResult);
     const on_conflict = insertstmt.on_conflict_();
     if (on_conflict) {
         const set_clause_list = on_conflict.set_clause_list().set_clause_list() || [];
-        set_clause_list.forEach(set_clause => traverse_set_clause(set_clause, dbSchema, insertColumns, traverseResult));
+        set_clause_list.forEach(set_clause => traverse_set_clause(set_clause, context, traverseResult));
     }
     const returning_clause = insertstmt.returning_clause();
-    const returninColumns = returning_clause ? traverse_target_list(returning_clause.target_list(), dbSchema, insertColumns, traverseResult) : [];
+    const returninColumns = returning_clause ? traverse_target_list(returning_clause.target_list(), context, traverseResult) : [];
     const result = {
         queryType: 'Insert',
         multipleRowsResult: false,
         parametersNullability: traverseResult.parameters.map(param => param.isNotNull),
-        columnsNullability: returninColumns.map(col => !col.is_nullable),
+        columns: returninColumns,
         parameterList: []
     };
     if (returning_clause) {
@@ -734,7 +1027,7 @@ function traverseInsertstmt(insertstmt, dbSchema) {
     }
     return result;
 }
-function traverse_insert_select_stmt(selectstmt, dbSchema, insertColumnlist, traverseResult) {
+function traverse_insert_select_stmt(selectstmt, context, traverseResult) {
     var _a, _b, _c, _d, _e;
     const simple_select = (_c = (_b = (_a = selectstmt.select_no_parens()) === null || _a === void 0 ? void 0 : _a.select_clause()) === null || _b === void 0 ? void 0 : _b.simple_select_intersect_list()) === null || _c === void 0 ? void 0 : _c[0];
     if (simple_select) {
@@ -743,27 +1036,27 @@ function traverse_insert_select_stmt(selectstmt, dbSchema, insertColumnlist, tra
             const values_clause = simple_select_pramary.values_clause();
             if (values_clause) {
                 values_clause.expr_list_list()
-                    .forEach(expr_list => traverse_insert_a_expr_list(expr_list, dbSchema, insertColumnlist, traverseResult));
+                    .forEach(expr_list => traverse_insert_a_expr_list(expr_list, context, traverseResult));
             }
             const target_list = (_e = simple_select_pramary.target_list_()) === null || _e === void 0 ? void 0 : _e.target_list();
             if (target_list) {
                 const from_clause = simple_select_pramary.from_clause();
-                const fromColumns = from_clause ? traverse_from_clause(from_clause, dbSchema, [], traverseResult) : [];
+                const fromColumns = from_clause ? traverse_from_clause(from_clause, Object.assign(Object.assign({}, context), { fromColumns: [] }), traverseResult) : [];
                 target_list.target_el_list().forEach((target_el, index) => {
-                    const targetResult = isNotNull_target_el(target_el, dbSchema, fromColumns, traverseResult);
+                    const targetResult = traverse_target_el(target_el, Object.assign(Object.assign({}, context), { fromColumns }), traverseResult);
                     if (isParameter(targetResult.column_name)) {
-                        traverseResult.parameters.at(-1).isNotNull = !insertColumnlist[index].is_nullable;
+                        traverseResult.parameters.at(-1).isNotNull = !context.fromColumns[index].is_nullable;
                     }
                 });
             }
         }
     }
 }
-function traverse_insert_a_expr_list(expr_list, dbSchema, insertColumns, traverseResult) {
+function traverse_insert_a_expr_list(expr_list, context, traverseResult) {
     expr_list.a_expr_list().forEach((a_expr, index) => {
-        const result = traverse_a_expr(a_expr, dbSchema, insertColumns, traverseResult);
+        const result = traverse_a_expr(a_expr, context, traverseResult);
         if (isParameter(result.column_name)) {
-            traverseResult.parameters.at(-1).isNotNull = !insertColumns[index].is_nullable;
+            traverseResult.parameters.at(-1).isNotNull = !context.fromColumns[index].is_nullable;
         }
     });
 }
@@ -772,12 +1065,18 @@ function traverseDeletestmt(deleteStmt, dbSchema, traverseResult) {
     const tableName = relation_expr.getText();
     const deleteColumns = dbSchema.filter(col => col.table_name === tableName);
     const returning_clause = deleteStmt.returning_clause();
-    const returninColumns = returning_clause ? traverse_target_list(returning_clause.target_list(), dbSchema, deleteColumns, traverseResult) : [];
+    const context = {
+        dbSchema,
+        fromColumns: deleteColumns,
+        collectNestedInfo: false,
+        collectDynamicQueryInfo: false
+    };
+    const returninColumns = returning_clause ? traverse_target_list(returning_clause.target_list(), context, traverseResult) : [];
     const result = {
         queryType: 'Delete',
         multipleRowsResult: false,
         parametersNullability: traverseResult.parameters.map(param => param.isNotNull),
-        columnsNullability: returninColumns.map(col => !col.is_nullable),
+        columns: returninColumns,
         parameterList: []
     };
     if (returning_clause) {
@@ -789,22 +1088,28 @@ function traverseUpdatestmt(updatestmt, dbSchema, traverseResult) {
     const relation_expr_opt_alias = updatestmt.relation_expr_opt_alias();
     const tableName = relation_expr_opt_alias.getText();
     const updateColumns = dbSchema.filter(col => col.table_name === tableName);
+    const context = {
+        dbSchema,
+        fromColumns: updateColumns,
+        collectNestedInfo: false,
+        collectDynamicQueryInfo: false
+    };
     updatestmt.set_clause_list().set_clause_list()
-        .forEach(set_clause => traverse_set_clause(set_clause, dbSchema, updateColumns, traverseResult));
+        .forEach(set_clause => traverse_set_clause(set_clause, context, traverseResult));
     const parametersBefore = traverseResult.parameters.length;
     const where_clause = updatestmt.where_or_current_clause();
     if (where_clause) {
         const a_expr = where_clause.a_expr();
-        traverse_a_expr(a_expr, dbSchema, updateColumns, traverseResult);
+        traverse_a_expr(a_expr, context, traverseResult);
     }
     const whereParameters = traverseResult.parameters.slice(parametersBefore);
     const returning_clause = updatestmt.returning_clause();
-    const returninColumns = returning_clause ? traverse_target_list(returning_clause.target_list(), dbSchema, updateColumns, traverseResult) : [];
+    const returninColumns = returning_clause ? traverse_target_list(returning_clause.target_list(), context, traverseResult) : [];
     const result = {
         queryType: 'Update',
         multipleRowsResult: false,
         parametersNullability: traverseResult.parameters.slice(0, parametersBefore).map(param => param.isNotNull),
-        columnsNullability: returninColumns.map(col => !col.is_nullable),
+        columns: returninColumns,
         parameterList: [],
         whereParamtersNullability: whereParameters.map(param => param.isNotNull)
     };
@@ -813,13 +1118,13 @@ function traverseUpdatestmt(updatestmt, dbSchema, traverseResult) {
     }
     return result;
 }
-function traverse_set_clause(set_clause, dbSchema, updateColumns, traverseResult) {
+function traverse_set_clause(set_clause, context, traverseResult) {
     const set_target = set_clause.set_target();
     const columnName = (0, select_columns_1.splitName)(set_target.getText());
-    const column = findColumn(columnName, updateColumns);
+    const column = findColumn(columnName, context.fromColumns);
     const a_expr = set_clause.a_expr();
-    const excludedColumns = updateColumns.map((col) => (Object.assign(Object.assign({}, col), { table_name: 'excluded' })));
-    const a_exprResult = traverse_a_expr(a_expr, dbSchema, updateColumns.concat(excludedColumns), traverseResult);
+    const excludedColumns = context.fromColumns.map((col) => (Object.assign(Object.assign({}, col), { table_name: 'excluded' })));
+    const a_exprResult = traverse_a_expr(a_expr, Object.assign(Object.assign({}, context), { fromColumns: context.fromColumns.concat(excludedColumns) }), traverseResult);
     if (isParameter(a_exprResult.column_name)) {
         traverseResult.parameters[traverseResult.parameters.length - 1].isNotNull = !column.is_nullable;
     }