typesql-cli 0.15.0 → 0.15.2

package/postgres-query-analyzer/traverse.js

@@ -4,15 +4,23 @@ 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 traverseSmt(stmt, dbSchema, generateNestedInfo) {
     const traverseResult = {
         columnsNullability: [],
         parameters: [],
         singleRow: false
     };
+    if (generateNestedInfo) {
+        traverseResult.relations = [];
+    }
+    const traverseContext = {
+        dbSchema,
+        generateNestedInfo,
+        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 +50,126 @@ 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;
+    }
+    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) });
+        return traverse_select_clause(select_clause, newContext, traverseResult);
     }
     return [];
 }
-function traverse_common_table_expr(common_table_expr, dbSchema, fromColumns, traverseResult) {
+function traverse_common_table_expr(common_table_expr, context, traverseResult) {
     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 columns = traverse_selectstmt(select_stmt, context, traverseResult);
         const columnsWithTalbeName = columns.map(col => (Object.assign(Object.assign({}, col), { table_name: tableName })));
         return columnsWithTalbeName;
     }
     return [];
 }
-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) {
+function traverse_simple_select_pramary(simple_select_pramary, context, traverseResult) {
     var _a;
     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);
+        traverse_a_expr(where_a_expr, newContext, traverseResult);
     }
-    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 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 +178,279 @@ 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);
             return columns;
         }
-        const column = isNotNull_target_el(target_el, dbSchema, fromColumns, traverseResult);
+        const column = isNotNull_target_el(target_el, context, traverseResult);
         return [column];
     });
     return columns;
 }
-function isNotNull_target_el(target_el, dbSchema, fromColumns, traverseResult) {
+function isNotNull_target_el(target_el, context, traverseResult) {
+    var _a;
     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 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;
+                }
+            });
+        }
         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) {
+function traverse_expr_or(a_expr_or, context, 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);
+        return traverse_expr_and(a_expr_and, context, traverseResult);
     }
     throw Error('traverse_expr_or -  Not expected:' + a_expr_or.getText());
 }
-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 +459,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,7 +472,9 @@ 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()) {
@@ -417,57 +484,77 @@ function traversec_expr(c_expr, dbSchema, fromColumns, traverseResult) {
             });
             return {
                 column_name: c_expr.PARAM().getText(),
-                is_nullable: false
+                is_nullable: false,
+                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);
         }
     }
     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,24 +563,41 @@ 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 whenIsNotNull = case_expr.when_clause_list().when_clause_list().every(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 thenExprList = a_expr_list.filter((_, index) => index % 2 == 1);
-    return thenExprList.every(thenExpr => traverse_a_expr(thenExpr, dbSchema, fromColumns, traverseResult));
+    const [whenExprList, thenExprList] = partition(a_expr_list, (index) => index % 2 === 0);
+    const whenExprResult = thenExprList.map((thenExpr, index) => {
+        traverse_a_expr(whenExprList[index], context, traverseResult);
+        const thenExprResult = traverse_a_expr(thenExpr, context, traverseResult);
+        return thenExprResult;
+    });
+    return whenExprResult.every(res => res);
 }
-function traversefunc_application(func_application, dbSchema, fromColumns, traverseResult) {
+function partition(array, predicate) {
+    return array.reduce((acc, curr, index) => {
+        if (predicate(index)) {
+            acc[0].push(curr);
+        }
+        else {
+            acc[1].push(curr);
+        }
+        return acc;
+    }, [[], []]);
+}
+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;
     }
@@ -511,15 +615,15 @@ function traversefunc_application(func_application, dbSchema, fromColumns, trave
         return true;
     }
     if (func_arg_expr_list) {
-        func_arg_expr_list.forEach(func_arg_expr => traversefunc_arg_expr(func_arg_expr, dbSchema, fromColumns, traverseResult));
+        func_arg_expr_list.forEach(func_arg_expr => traversefunc_arg_expr(func_arg_expr, context, traverseResult));
     }
     return false;
 }
-function traversefunc_expr_common_subexpr(func_expr_common_subexpr, dbSchema, fromColumns, traverseResult) {
+function traversefunc_expr_common_subexpr(func_expr_common_subexpr, context, traverseResult) {
     if (func_expr_common_subexpr.COALESCE()) {
         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);
+            const paramResult = traverse_a_expr(func_arg_expr, context, traverseResult);
             if (isParameter(paramResult.column_name)) {
                 traverseResult.parameters[traverseResult.parameters.length - 1].isNotNull = false;
                 paramResult.is_nullable = true;
@@ -530,14 +634,14 @@ function traversefunc_expr_common_subexpr(func_expr_common_subexpr, dbSchema, fr
     }
     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());
@@ -554,18 +658,20 @@ 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();
@@ -573,8 +679,23 @@ function traverse_table_ref(table_ref, dbSchema, fromColumns, traverseResult) {
     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);
+        if (context.generateNestedInfo) {
+            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();
@@ -583,36 +704,67 @@ function traverse_table_ref(table_ref, dbSchema, fromColumns, traverseResult) {
         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 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.generateNestedInfo) {
+                collectNestedInfo(joinQual, resultColumns, 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, context, traverseResult);
         const withAlias = columns.map(col => (Object.assign(Object.assign({}, col), { table_name: alias || col.table_name })));
         return withAlias;
     }
     return allColumns;
 }
+function collectNestedInfo(joinQual, resultColumns, traverseResult) {
+    var _a;
+    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()));
+        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 [];
 }
@@ -696,20 +848,25 @@ 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,
+        generateNestedInfo: 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) {
@@ -717,7 +874,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) {
@@ -726,68 +883,93 @@ 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 = isNotNull_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;
         }
     });
 }
 function traverseDeletestmt(deleteStmt, dbSchema, traverseResult) {
-    return {
+    const relation_expr = deleteStmt.relation_expr_opt_alias().relation_expr();
+    const tableName = relation_expr.getText();
+    const deleteColumns = dbSchema.filter(col => col.table_name === tableName);
+    const returning_clause = deleteStmt.returning_clause();
+    const context = {
+        dbSchema,
+        fromColumns: deleteColumns,
+        generateNestedInfo: 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: [],
+        columns: returninColumns,
         parameterList: []
     };
+    if (returning_clause) {
+        result.returning = true;
+    }
+    return result;
 }
 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,
+        generateNestedInfo: 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);
-    return {
+    const returning_clause = updatestmt.returning_clause();
+    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: [],
+        columns: returninColumns,
         parameterList: [],
         whereParamtersNullability: whereParameters.map(param => param.isNotNull)
     };
+    if (returning_clause) {
+        result.returning = true;
+    }
+    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;
     }