typesql-cli 0.18.3 → 0.18.4

package/postgres-query-analyzer/traverse.js

@@ -2,21 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultOptions = defaultOptions;
 exports.traverseSmt = traverseSmt;
+exports.parseReturnType = parseReturnType;
 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");
+const postgres_1 = require("@wsporto/typesql-parser/postgres");
 function defaultOptions() {
     return {
         collectNestedInfo: false,
         collectDynamicQueryInfo: false
     };
 }
-function traverseSmt(stmt, dbSchema, checkConstraints, options) {
+function traverseSmt(stmt, dbSchema, checkConstraints, userFunctions, options) {
     const { collectNestedInfo = false, collectDynamicQueryInfo = false } = options;
     const traverseResult = {
         columnsNullability: [],
-        parameters: [],
-        singleRow: false
+        parameters: []
     };
     if (collectNestedInfo) {
         traverseResult.relations = [];
@@ -35,7 +36,10 @@ function traverseSmt(stmt, dbSchema, checkConstraints, options) {
         collectNestedInfo,
         collectDynamicQueryInfo,
         fromColumns: [],
-        checkConstraints
+        parentColumns: [],
+        withColumns: [],
+        checkConstraints,
+        userFunctions
     };
     const selectstmt = stmt.selectstmt();
     if (selectstmt) {
@@ -82,15 +86,15 @@ function getInParameterList(ctx) {
 }
 function traverseSelectstmt(selectstmt, context, traverseResult) {
     const paramIsListResult = getInParameterList(selectstmt);
-    const columns = traverse_selectstmt(selectstmt, context, traverseResult);
+    const selectResult = traverse_selectstmt(selectstmt, context, traverseResult);
     //select parameters are collected after from paramters
     traverseResult.parameters.sort((param1, param2) => param1.paramIndex - param2.paramIndex);
-    const multipleRowsResult = !isSingleRowResult(selectstmt, context.dbSchema);
+    const multipleRowsResult = !(selectResult.singleRow || isSingleRowResult(selectstmt, selectResult.columns));
     const limit = checkLimit(selectstmt);
     const postgresTraverseResult = {
         queryType: 'Select',
         multipleRowsResult,
-        columns,
+        columns: selectResult.columns,
         parametersNullability: traverseResult.parameters.map(param => (Object.assign({ isNotNull: param.isNotNull }, addConstraintIfNotNull(param.checkConstraint)))),
         parameterList: paramIsListResult,
         limit
@@ -108,22 +112,23 @@ function traverse_selectstmt(selectstmt, context, traverseResult) {
     if (select_no_parens) {
         return traverse_select_no_parens(select_no_parens, context, traverseResult);
     }
-    return [];
+    //select_with_parens
+    return {
+        columns: [],
+        singleRow: true
+    };
 }
 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 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 withResult = traverse_common_table_expr(common_table_expr, context, traverseResult);
+            context.withColumns.push(...withResult);
         });
     }
     const select_clause = select_no_parens.select_clause();
-    const newContext = Object.assign(Object.assign({}, context), { fromColumns: withColumns.concat(context.fromColumns) });
-    const selectResult = traverse_select_clause(select_clause, newContext, traverseResult);
+    const selectResult = traverse_select_clause(select_clause, context, traverseResult);
     const select_limit = select_no_parens.select_limit();
     if (select_limit) {
         const numParamsBefore = traverseResult.parameters.length;
@@ -159,8 +164,8 @@ 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();
     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 })));
+    const selectResult = traverse_selectstmt(select_stmt, Object.assign(Object.assign({}, context), { collectDynamicQueryInfo: false }), traverseResult);
+    const columnsWithTalbeName = selectResult.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({
@@ -173,45 +178,55 @@ function traverse_common_table_expr(common_table_expr, context, 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], context, traverseResult);
-    }
+    const mainSelectResult = traverse_simple_select_intersect(simple_select_intersect_list[0], context, traverseResult);
+    let columns = mainSelectResult.columns;
     //union
     for (let index = 1; index < simple_select_intersect_list.length; index++) {
-        const unionNotNull = traverse_simple_select_intersect(simple_select_intersect_list[index], context, traverseResult);
-        selectColumns = selectColumns.map((value, columnIndex) => {
-            const col = Object.assign({ column_name: value.column_name, is_nullable: value.is_nullable || unionNotNull[columnIndex].is_nullable, table_name: '', table_schema: '', type: value.type }, (value.column_default && { column_default: value.column_default }));
+        const unionResult = traverse_simple_select_intersect(simple_select_intersect_list[index], context, traverseResult);
+        columns = columns.map((value, columnIndex) => {
+            const col = Object.assign({ column_name: value.column_name, is_nullable: value.is_nullable || unionResult.columns[columnIndex].is_nullable, table_name: '', table_schema: '', type: value.type }, (value.column_default && { column_default: value.column_default }));
             return col;
         });
     }
-    return selectColumns;
+    return {
+        columns,
+        singleRow: simple_select_intersect_list.length == 1 ? mainSelectResult.singleRow : false
+    };
 }
 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, context, traverseResult);
     }
-    return [];
+    return {
+        columns: [],
+        singleRow: true
+    };
 }
 function traverse_simple_select_pramary(simple_select_pramary, context, traverseResult) {
     var _a, _b, _c, _d, _e;
-    const fromColumns = [];
+    let fromResult = {
+        columns: [],
+        singleRow: false
+    };
     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, context, traverseResult);
-        const fieldsNotNull = where_clause != null ? fields.map(field => checkIsNullable(where_clause, field)) : fields;
-        fromColumns.push(...fieldsNotNull);
+        fromResult = traverse_from_clause(from_clause, context, traverseResult);
+        fromResult.columns = where_clause != null ? fromResult.columns.map(field => checkIsNullable(where_clause, field)) : fromResult.columns;
     }
     const values_clause = simple_select_pramary.values_clause();
     if (values_clause) {
         const valuesColumns = traverse_values_clause(values_clause, context, traverseResult);
-        return valuesColumns;
+        return {
+            columns: valuesColumns,
+            singleRow: false
+        };
     }
     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) });
+    //context.fromColumns only becase of insert. update
+    const newContext = Object.assign(Object.assign({}, context), { fromColumns: [...context.fromColumns, ...fromResult.columns, ...context.parentColumns] });
     if (where_a_expr) {
         const numParamsBefore = traverseResult.parameters.length;
         traverse_a_expr(where_a_expr, newContext, traverseResult);
@@ -236,7 +251,10 @@ function traverse_simple_select_pramary(simple_select_pramary, context, traverse
         traverse_a_expr(having_expr, newContext, traverseResult);
     }
     const filteredColumns = filterColumns_simple_select_pramary(simple_select_pramary, newContext, traverseResult);
-    return filteredColumns;
+    return {
+        columns: filteredColumns,
+        singleRow: fromResult.singleRow
+    };
 }
 function extractRelations(a_expr) {
     const columnsRef = collectContextsOfType(a_expr, PostgreSQLParser_1.ColumnrefContext);
@@ -340,7 +358,7 @@ function traverse_target_el(target_el, context, traverseResult) {
                 parameters
             });
         }
-        return Object.assign({ column_name: alias || exprResult.column_name, is_nullable: exprResult.is_nullable && exprResult.column_default !== true, table_name: exprResult.table_name, table_schema: exprResult.table_schema, type: exprResult.type }, (exprResult.jsonType != null && { jsonType: exprResult.jsonType }));
+        return Object.assign(Object.assign({ column_name: alias || exprResult.column_name, is_nullable: exprResult.is_nullable && exprResult.column_default !== true, table_name: exprResult.table_name, table_schema: exprResult.table_schema, type: exprResult.type }, (exprResult.column_key != null && { column_key: exprResult.column_key })), (exprResult.jsonType != null && { jsonType: exprResult.jsonType }));
     }
     throw Error('Column not found');
 }
@@ -470,6 +488,7 @@ function traverse_expr_is_not(a_expr_is_not, context, traverseResult) {
         const result = traverse_expr_compare(a_expr_compare, context, traverseResult);
         if (a_expr_is_not.IS() && a_expr_is_not.NULL_P()) {
             checkParamterNullability(result, traverseResult);
+            return Object.assign(Object.assign({}, result), { is_nullable: false });
         }
         return result;
     }
@@ -518,10 +537,10 @@ function traverse_expr_compare(a_expr_compare, context, traverseResult) {
         const result = traverse_select_with_parens(select_with_parens, context, traverseResult);
         return {
             column_name: '?column?',
-            is_nullable: result.some(col => col.is_nullable),
+            is_nullable: result.columns.some(col => col.is_nullable),
             table_name: '',
             table_schema: '',
-            type: result[0].type
+            type: result.columns[0].type
         };
     }
     const a_expr = a_expr_compare.a_expr();
@@ -710,7 +729,7 @@ function getNameAndTypeIdFromAExprConst(a_expr_const) {
     if (a_expr_const.NULL_P()) {
         return {
             name: a_expr_const.getText(),
-            type: 'unknown'
+            type: 'null'
         };
     }
     return {
@@ -742,12 +761,15 @@ function traversec_expr(c_expr, context, traverseResult) {
         const columnref = c_expr.columnref();
         if (columnref) {
             if (context.columnRefIsRecord) {
+                const table = (0, select_columns_1.splitTableName)(columnref.getText());
+                const columns = filterColumns(context.fromColumns, table);
                 return {
                     column_name: columnref.getText(),
                     is_nullable: false,
                     table_name: '',
                     table_schema: '',
-                    type: 'unknown',
+                    type: 'record',
+                    recordTypes: columns
                 };
             }
             else {
@@ -782,6 +804,7 @@ function traversec_expr(c_expr, context, traverseResult) {
         }
         const fun_expr = c_expr.func_expr();
         if (fun_expr) {
+            context.columnRefIsRecord = undefined;
             const func_application = fun_expr.func_application();
             if (func_application) {
                 if (is_json_build_object_func(func_application)) {
@@ -807,14 +830,14 @@ function traversec_expr(c_expr, context, traverseResult) {
         }
         const select_with_parens = c_expr.select_with_parens();
         if (select_with_parens) {
-            const result = traverse_select_with_parens(select_with_parens, context, traverseResult);
+            const result = traverse_select_with_parens(select_with_parens, Object.assign(Object.assign({}, context), { parentColumns: context.fromColumns, fromColumns: [] }), traverseResult);
             return {
                 column_name: '?column?',
-                is_nullable: true,
+                is_nullable: result.columns[0].jsonType ? result.columns[0].is_nullable : true,
                 table_name: '',
                 table_schema: '',
-                type: result[0].type,
-                jsonType: result[0].jsonType
+                type: result.columns[0].type,
+                jsonType: result.columns[0].jsonType
             };
         }
         const a_expr_in_parens = c_expr._a_expr_in_parens;
@@ -830,8 +853,8 @@ function traversec_expr(c_expr, context, traverseResult) {
                 is_nullable: expr_list.some(col => col.is_nullable),
                 table_name: '',
                 table_schema: '',
-                type: 'unknown',
-                recordTypes: expr_list.map(rec => ({ type: rec.type, notNull: !rec.is_nullable }))
+                type: 'record',
+                recordTypes: expr_list.map(expr => (Object.assign(Object.assign({}, expr), { column_name: '' })))
             };
         }
         const implicit_row = c_expr.implicit_row();
@@ -867,7 +890,7 @@ function traversec_expr(c_expr, context, traverseResult) {
 function filterColumns(fromColumns, fieldName) {
     return fromColumns.filter(col => (fieldName.prefix === '' || col.table_name === fieldName.prefix)
         && (fieldName.name === '*' || col.column_name === fieldName.name)).map(col => {
-        const result = Object.assign({ column_name: col.column_name, is_nullable: col.is_nullable, table_name: col.table_name, table_schema: col.table_schema, type: col.type }, (col.original_is_nullable !== undefined && { original_is_nullable: col.original_is_nullable }));
+        const result = Object.assign(Object.assign(Object.assign({ column_name: col.column_name, is_nullable: col.is_nullable, table_name: col.table_name, table_schema: col.table_schema, type: col.type }, (col.column_key !== undefined) && { column_key: col.column_key }), (col.jsonType !== undefined) && { jsonType: col.jsonType }), (col.original_is_nullable !== undefined && { original_is_nullable: col.original_is_nullable }));
         return result;
     });
 }
@@ -884,22 +907,33 @@ function traversec_expr_case(c_expr_case, context, 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, context, traverseResult).is_nullable : false;
+    const elseResult = elseExpr ? traverse_a_expr(elseExpr, Object.assign({}, context), traverseResult) : null;
+    const elseIsNotNull = (elseResult === null || elseResult === void 0 ? void 0 : elseResult.is_nullable) === false || false;
     const notNull = elseIsNotNull && whenIsNotNull;
     return {
         column_name: '?column?',
         is_nullable: !notNull,
         table_name: '',
         table_schema: '',
-        type: (_b = whenResult[0].type) !== null && _b !== void 0 ? _b : 'unknown'
+        type: (_b = whenResult[0].type) !== null && _b !== void 0 ? _b : 'unknown',
+        jsonType: allJsonTypesMatch(whenResult, elseResult) ? whenResult[0].jsonType : undefined
     };
 }
+function allJsonTypesMatch(whenResultList, elseResult) {
+    var _a;
+    const firstType = (_a = whenResultList[0]) === null || _a === void 0 ? void 0 : _a.jsonType;
+    const allMatch = whenResultList.every(res => {
+        const match = res.jsonType == firstType;
+        return match;
+    }) && ((elseResult === null || elseResult === void 0 ? void 0 : elseResult.type) === 'null' || (elseResult === null || elseResult === void 0 ? void 0 : elseResult.jsonType) == firstType);
+    return allMatch;
+}
 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], context, traverseResult);
-        const thenExprResult = traverse_a_expr(thenExpr, context, traverseResult);
+        const thenExprResult = traverse_a_expr(thenExpr, Object.assign(Object.assign({}, context), { filter_expr: whenExprList[index] }), traverseResult);
         return thenExprResult;
     });
     const notNull = whenExprResult.every(res => res);
@@ -908,7 +942,8 @@ function traversewhen_clause(when_clause, context, traverseResult) {
         is_nullable: !notNull,
         table_name: '',
         table_schema: '',
-        type: whenExprResult[0].type
+        type: whenExprResult[0].type,
+        jsonType: whenExprResult[0].jsonType
     };
 }
 function partition(array, predicate) {
@@ -952,14 +987,9 @@ function mapJsonBuildArgsToJsonProperty(args, filterExpr) {
     return properties;
 }
 function inferJsonNullability(columns, filterExpr) {
-    const someIsNotNull = columns.some(col => filterExpr && col.original_is_nullable === false && isNotNull_a_expr(col, filterExpr));
+    const tables = columns.filter(col => filterExpr && col.original_is_nullable === false && isNotNull_a_expr(col, filterExpr)).map(col => col.table_name);
     const fields = columns.map(col => {
-        if (someIsNotNull) {
-            return col.original_is_nullable != null ? !col.original_is_nullable : Boolean(filterExpr && isNotNull_a_expr(col, filterExpr));
-        }
-        else {
-            return !col.is_nullable || Boolean(filterExpr && isNotNull_a_expr(col, filterExpr));
-        }
+        return col.original_is_nullable != null && tables.includes(col.table_name) ? !col.original_is_nullable : !col.is_nullable;
     });
     return fields;
 }
@@ -986,9 +1016,9 @@ function traverse_json_build_obj_func(func_application, context, traverseResult)
     const columnName = ((_a = func_application.func_name()) === null || _a === void 0 ? void 0 : _a.getText()) || func_application.getText();
     const func_arg_expr_list = ((_b = func_application.func_arg_list()) === null || _b === void 0 ? void 0 : _b.func_arg_expr_list()) || [];
     const argsResult = func_arg_expr_list.map(func_arg_expr => traversefunc_arg_expr(func_arg_expr, context, traverseResult));
-    return {
+    const result = {
         column_name: columnName,
-        is_nullable: true,
+        is_nullable: false,
         table_name: '',
         table_schema: '',
         type: 'json',
@@ -997,12 +1027,13 @@ function traverse_json_build_obj_func(func_application, context, traverseResult)
             properties: mapJsonBuildArgsToJsonProperty(argsResult, context.filter_expr),
         }
     };
+    return result;
 }
 function traverse_json_agg(func_application, context, traverseResult) {
     var _a, _b;
     const columnName = ((_a = func_application.func_name()) === null || _a === void 0 ? void 0 : _a.getText()) || func_application.getText();
     const func_arg_expr_list = ((_b = func_application.func_arg_list()) === null || _b === void 0 ? void 0 : _b.func_arg_expr_list()) || [];
-    const argsResult = func_arg_expr_list.map(func_arg_expr => traversefunc_arg_expr(func_arg_expr, context, traverseResult));
+    const argsResult = func_arg_expr_list.map(func_arg_expr => traversefunc_arg_expr(func_arg_expr, Object.assign(Object.assign({}, context), { columnRefIsRecord: true }), traverseResult));
     const result = {
         column_name: columnName,
         is_nullable: context.filter_expr != null,
@@ -1011,11 +1042,24 @@ function traverse_json_agg(func_application, context, traverseResult) {
         type: 'json[]',
         jsonType: {
             name: 'json[]',
-            properties: argsResult.map(arg => arg.jsonType || { name: 'json_field', type: arg.type, notNull: !arg.is_nullable })
+            properties: createJsonTypeForJsonAgg(argsResult[0], context.filter_expr)
         }
     };
     return result;
 }
+function createJsonTypeForJsonAgg(arg, filter_expr) {
+    if (arg.recordTypes) {
+        const jsonType = mapRecordsToJsonType(arg.recordTypes, filter_expr);
+        return [jsonType];
+    }
+    return [arg.jsonType || { name: 'json_field', type: arg.type, notNull: !arg.is_nullable }];
+}
+function mapRecordsToJsonType(recordTypes, filterExpr) {
+    const jsonNullability = inferJsonNullability(recordTypes, filterExpr);
+    const fields = recordTypes.map((col, index) => ({ name: col.column_name ? col.column_name : `f${index + 1}`, type: col.type, notNull: jsonNullability[index] }));
+    const jsonType = transformFieldsToJsonObjType(fields);
+    return jsonType;
+}
 function traversefunc_application(func_application, context, traverseResult) {
     var _a;
     const functionName = getFunctionName(func_application);
@@ -1023,22 +1067,7 @@ function traversefunc_application(func_application, context, traverseResult) {
     if (functionName === 'row_to_json') {
         const argResult = traversefunc_arg_expr(func_arg_expr_list[0], Object.assign(Object.assign({}, context), { columnRefIsRecord: true }), traverseResult);
         if (argResult.recordTypes) {
-            const fields = argResult.recordTypes.map((record, index) => ({ name: `f${index + 1}`, type: record.type, notNull: record.notNull }));
-            const jsonType = transformFieldsToJsonObjType(fields);
-            return {
-                column_name: functionName,
-                is_nullable: false,
-                table_name: '',
-                table_schema: '',
-                type: 'json',
-                jsonType
-            };
-        }
-        else {
-            const columns = filterColumns(context.fromColumns, { name: '*', prefix: argResult.column_name });
-            const jsonNullability = inferJsonNullability(columns, context.filter_expr);
-            const fields = columns.map((col, index) => ({ name: col.column_name, type: col.type, notNull: jsonNullability[index] }));
-            const jsonType = transformFieldsToJsonObjType(fields);
+            const jsonType = mapRecordsToJsonType(argResult.recordTypes, context.filter_expr);
             return {
                 column_name: functionName,
                 is_nullable: false,
@@ -1170,6 +1199,19 @@ function traversefunc_application(func_application, context, traverseResult) {
     if (functionName === 'sum') {
         return Object.assign(Object.assign({}, argsResult[0]), { column_name: functionName, is_nullable: true, type: argsResult[0].type ? mapSumType(argsResult[0].type) : 'unknown' });
     }
+    if (functionName === 'json_object_agg') {
+        return {
+            column_name: functionName,
+            is_nullable: false,
+            table_name: '',
+            table_schema: '',
+            type: 'json',
+            jsonType: {
+                name: 'json_map',
+                type: argsResult[1].jsonType || { name: 'json_field', type: argsResult[1].type, notNull: !argsResult[1].is_nullable }
+            }
+        };
+    }
     return {
         column_name: functionName,
         is_nullable: true,
@@ -1268,27 +1310,40 @@ function checkIsNullable(where_clause, field) {
 function traverse_from_clause(from_clause, context, traverseResult) {
     const from_list = from_clause.from_list();
     if (from_list) {
-        return traverse_from_list(from_list, context, traverseResult);
+        const fromListResult = traverse_from_list(from_list, context, traverseResult);
+        return fromListResult;
     }
-    return [];
+    return {
+        columns: [],
+        singleRow: false
+    };
 }
 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;
+    const fromListResult = from_list.table_ref_list().map(table_ref => traverse_table_ref(table_ref, context, traverseResult));
+    const columns = fromListResult.flatMap(tableRes => tableRes.columns);
+    return {
+        columns: columns,
+        singleRow: fromListResult.length === 1 ? fromListResult[0].singleRow : false
+    };
+}
+function getFromColumns(tableName, withColumns, dbSchema) {
+    const filteredWithColumns = withColumns.filter(col => col.table_name.toLowerCase() === tableName.name.toLowerCase());
+    const filteredSchema = filteredWithColumns.length > 0 ? filteredWithColumns : dbSchema.filter(col => col.table_name.toLowerCase() === tableName.name.toLowerCase());
+    return filteredSchema;
 }
 function traverse_table_ref(table_ref, context, traverseResult) {
-    var _a, _b, _c, _d;
-    const { fromColumns, dbSchema } = context;
+    var _a, _b, _c, _d, _e, _f, _g;
     const allColumns = [];
     const relation_expr = table_ref.relation_expr();
     const aliasClause = table_ref.alias_clause();
     const aliasNameList = (_b = (_a = aliasClause === null || aliasClause === void 0 ? void 0 : aliasClause.name_list()) === null || _a === void 0 ? void 0 : _a.name_list()) === null || _b === void 0 ? void 0 : _b.map(name => name.getText());
     const alias = aliasClause ? aliasClause.colid().getText() : '';
     if (relation_expr) {
-        const tableName = traverse_relation_expr(relation_expr, dbSchema);
+        const tableName = traverse_relation_expr(relation_expr);
+        const fromColumns = getFromColumns(tableName, context.withColumns, context.dbSchema);
         const tableNameWithAlias = alias ? alias : tableName.name;
-        const fromColumnsResult = fromColumns.concat(dbSchema).filter(col => col.table_name.toLowerCase() === tableName.name.toLowerCase())
-            .map(col => (Object.assign(Object.assign({}, col), { table_name: tableNameWithAlias.toLowerCase() })));
+        const columnsWithAlias = fromColumns.map(col => (Object.assign(Object.assign({}, col), { table_name: tableNameWithAlias.toLowerCase() })));
+        const fromColumnsResult = columnsWithAlias.concat(context.parentColumns);
         allColumns.push(...fromColumnsResult);
         if (context.collectNestedInfo) {
             const key = fromColumnsResult.filter(col => col.column_key === 'PRI');
@@ -1304,47 +1359,78 @@ function traverse_table_ref(table_ref, context, traverseResult) {
             };
             (_d = traverseResult.relations) === null || _d === void 0 ? void 0 : _d.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, original_is_nullable: col.is_nullable }))) : 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 joinList = extractJoins(table_ref);
+        const joinColumns = joinList.flatMap((join) => {
+            const joinType = join.joinType; //INNER, LEFT
+            const joinQual = join.joinQual;
+            const numParamsBefore = traverseResult.parameters.length;
+            const joinTableRefResult = traverse_table_ref(join.tableRef, context, traverseResult);
+            const isLeftJoin = joinType === null || joinType === void 0 ? void 0 : joinType.LEFT();
+            const filteredColumns = joinQual && (joinQual === null || joinQual === void 0 ? void 0 : joinQual.USING()) ? filterUsingColumns(joinTableRefResult.columns, joinQual) : joinTableRefResult.columns;
+            const resultColumns = isLeftJoin ? filteredColumns.map(col => (Object.assign(Object.assign({}, col), { is_nullable: true, original_is_nullable: col.is_nullable }))) : filteredColumns;
+            if (context.collectNestedInfo && joinQual) {
+                collectNestedInfo(joinQual, resultColumns, traverseResult);
+            }
+            if (context.collectDynamicQueryInfo) {
+                const parameters = traverseResult.parameters.slice(numParamsBefore).map((_, index) => index + numParamsBefore);
+                collectDynamicQueryInfoTableRef(join.tableRef, joinType, joinQual, resultColumns, parameters, traverseResult);
+            }
+            return resultColumns;
+        });
+        allColumns.push(...joinColumns);
+    }
+    const func_table = table_ref.func_table();
+    if (func_table) {
+        const funcAlias = ((_g = (_f = (_e = table_ref.func_alias_clause()) === null || _e === void 0 ? void 0 : _e.alias_clause()) === null || _f === void 0 ? void 0 : _f.colid()) === null || _g === void 0 ? void 0 : _g.getText()) || '';
+        const result = traverse_func_table(func_table, context, traverseResult);
+        const resultWithAlias = result.columns.map(col => (Object.assign(Object.assign({}, col), { table_name: funcAlias || col.table_name })));
+        return {
+            columns: resultWithAlias,
+            singleRow: result.singleRow
+        };
     }
     const select_with_parens = table_ref.select_with_parens();
     if (select_with_parens) {
         const columns = traverse_select_with_parens(select_with_parens, Object.assign(Object.assign({}, context), { collectDynamicQueryInfo: false }), traverseResult);
-        const withAlias = columns.map((col, i) => ({
+        const withAlias = columns.columns.map((col, i) => ({
             column_name: (aliasNameList === null || aliasNameList === void 0 ? void 0 : aliasNameList[i]) || col.column_name,
             is_nullable: col.is_nullable,
             table_name: alias || col.table_name,
             table_schema: col.table_schema,
             type: col.type
         }));
-        return withAlias;
+        return {
+            columns: withAlias,
+            singleRow: false
+        };
     }
-    return allColumns;
+    return {
+        columns: allColumns,
+        singleRow: false
+    };
+}
+function extractJoins(table_ref) {
+    const joinList = [];
+    let currentJoinType = null;
+    for (const child of table_ref.children || []) {
+        if (child instanceof PostgreSQLParser_1.Join_typeContext) {
+            currentJoinType = child;
+        }
+        if (child instanceof PostgreSQLParser_1.Table_refContext) {
+            joinList.push({ joinQual: null, joinType: currentJoinType, tableRef: child });
+            currentJoinType = null;
+        }
+        if (child instanceof PostgreSQLParser_1.Join_qualContext) {
+            const lastJoin = joinList.at(-1);
+            if (lastJoin) {
+                lastJoin.joinQual = child;
+            }
+        }
+    }
+    return joinList;
 }
 function collectDynamicQueryInfoTableRef(table_ref, joinType, joinQual, columns, parameters, traverseResult) {
     var _a, _b;
@@ -1414,16 +1500,88 @@ function traverse_select_with_parens(select_with_parens, context, traverseResult
     if (select_no_parens) {
         return traverse_select_no_parens(select_no_parens, context, traverseResult);
     }
-    return [];
+    return {
+        columns: [],
+        singleRow: false
+    };
+}
+function traverse_func_table(func_table, context, traverseResult) {
+    const func_expr_windowless = func_table.func_expr_windowless();
+    if (func_expr_windowless) {
+        const result = traverse_func_expr_windowless(func_expr_windowless, context, traverseResult);
+        return result;
+    }
+    throw Error('Stmt not supported: ' + func_table.getText());
+}
+function parseReturnType(returnType) {
+    const trimmed = returnType.trim();
+    // Handle TABLE(...)
+    if (trimmed.toLowerCase().startsWith('table(') && trimmed.endsWith(')')) {
+        const inside = trimmed.slice(6, -1); // remove "TABLE(" and final ")"
+        const columns = [];
+        const parts = inside.split(',').map(part => part.trim());
+        for (const part of parts) {
+            const match = part.match(/^(\w+)\s+(.+)$/);
+            if (!match) {
+                throw new Error(`Invalid column definition: ${part}`);
+            }
+            const [, name, type] = match;
+            columns.push({ name, type });
+        }
+        return { kind: 'table', columns };
+    }
+    // Handle SETOF typename
+    const setofMatch = trimmed.match(/^SETOF\s+(\w+)$/i);
+    if (setofMatch) {
+        return { kind: 'setof', table: setofMatch[1] };
+    }
+    throw new Error(`Unsupported return type format: ${returnType}`);
+}
+function traverse_func_expr_windowless(func_expr_windowless, context, traverseResult) {
+    const func_application = func_expr_windowless.func_application();
+    if (func_application) {
+        const func_name = func_application.func_name().getText().toLowerCase();
+        const funcSchema = context.userFunctions.find(func => func.function_name.toLowerCase() === func_name);
+        if (funcSchema) {
+            const definition = funcSchema.definition;
+            const returnType = parseReturnType(funcSchema.return_type);
+            const functionColumns = returnType.kind === 'table' ? returnType.columns.map(col => {
+                const columnInfo = {
+                    column_name: col.name,
+                    type: col.type,
+                    is_nullable: true,
+                    table_name: '',
+                    table_schema: ''
+                };
+                return columnInfo;
+            }) : context.dbSchema.filter(col => col.table_name.toLowerCase() === returnType.table);
+            if (funcSchema.language.toLowerCase() === 'sql') {
+                const parser = (0, postgres_1.parseSql)(definition);
+                const selectstmt = parser.stmt().selectstmt();
+                const { columns, multipleRowsResult } = traverseSelectstmt(selectstmt, context, traverseResult);
+                return {
+                    columns: columns.map((c) => (Object.assign(Object.assign({}, c), { table_name: funcSchema.function_name }))),
+                    singleRow: !multipleRowsResult
+                };
+            }
+            else {
+                return {
+                    columns: functionColumns,
+                    singleRow: false
+                };
+            }
+        }
+    }
+    throw Error('Stmt not supported: ' + func_expr_windowless.getText());
 }
-function traverse_relation_expr(relation_expr, dbSchema) {
+function traverse_relation_expr(relation_expr) {
     const qualified_name = relation_expr.qualified_name();
-    const name = traverse_qualified_name(qualified_name, dbSchema);
+    const name = traverse_qualified_name(qualified_name);
     return name;
 }
-function traverse_qualified_name(qualified_name, dbSchema) {
+function traverse_qualified_name(qualified_name) {
     var _a, _b;
-    const colid_name = qualified_name.colid() ? get_colid_text(qualified_name.colid(), dbSchema) : '';
+    const colid_name = qualified_name.colid() ? get_colid_text(qualified_name.colid()) : '';
     const indirection_el_list = (_a = qualified_name.indirection()) === null || _a === void 0 ? void 0 : _a.indirection_el_list();
     if (indirection_el_list && indirection_el_list.length === 1) {
         return {
@@ -1436,22 +1594,22 @@ function traverse_qualified_name(qualified_name, dbSchema) {
         alias: ''
     };
 }
-function get_colid_text(colid, dbSchema) {
+function get_colid_text(colid) {
     const identifier = colid.identifier();
     if (identifier) {
-        return traverse_identifier(identifier, dbSchema);
+        return traverse_identifier(identifier);
     }
     const unreserved_keyword = colid.unreserved_keyword();
     if (unreserved_keyword) {
-        return traverse_unreserved_keyword(unreserved_keyword, dbSchema);
+        return traverse_unreserved_keyword(unreserved_keyword);
     }
     return '';
 }
-function traverse_identifier(identifier, dbSchema) {
+function traverse_identifier(identifier) {
     const tableName = identifier.Identifier().getText();
     return tableName;
 }
-function traverse_unreserved_keyword(unreserved_keyword, dbSchema) {
+function traverse_unreserved_keyword(unreserved_keyword) {
     return unreserved_keyword.getText();
 }
 function paramIsList(c_expr) {
@@ -1486,8 +1644,7 @@ function paramIsList(c_expr) {
 function traverseInsertstmt(insertstmt, dbSchema) {
     const traverseResult = {
         columnsNullability: [],
-        parameters: [],
-        singleRow: false
+        parameters: []
     };
     const insert_target = insertstmt.insert_target();
     const tableName = insert_target.getText();
@@ -1499,7 +1656,10 @@ function traverseInsertstmt(insertstmt, dbSchema) {
     const context = {
         dbSchema,
         fromColumns: insertColumns,
+        parentColumns: [],
+        withColumns: [],
         checkConstraints: {},
+        userFunctions: [],
         collectNestedInfo: false,
         collectDynamicQueryInfo: false
     };
@@ -1535,7 +1695,10 @@ function traverseDeletestmt(deleteStmt, dbSchema, traverseResult) {
     const context = {
         dbSchema,
         fromColumns: deleteColumns,
+        parentColumns: [],
+        withColumns: [],
         checkConstraints: {},
+        userFunctions: [],
         collectNestedInfo: false,
         collectDynamicQueryInfo: false
     };
@@ -1570,12 +1733,12 @@ function traverseUpdatestmt(updatestmt, traverseContext, traverseResult) {
     updatestmt.set_clause_list().set_clause_list()
         .forEach(set_clause => traverse_set_clause(set_clause, context, traverseResult));
     const from_clause = updatestmt.from_clause();
-    const fromColumns = from_clause ? traverse_from_clause(from_clause, context, traverseResult) : [];
+    const fromResult = from_clause ? traverse_from_clause(from_clause, context, traverseResult) : { columns: [], singleRow: true };
     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, Object.assign(Object.assign({}, context), { fromColumns: updateColumns.concat(fromColumns) }), traverseResult);
+        traverse_a_expr(a_expr, Object.assign(Object.assign({}, context), { fromColumns: updateColumns.concat(fromResult.columns) }), traverseResult);
     }
     const whereParameters = traverseResult.parameters.slice(parametersBefore);
     const returning_clause = updatestmt.returning_clause();
@@ -1840,7 +2003,7 @@ function isParameter(str) {
     const paramPattern = /^\$[0-9]+(::[a-zA-Z_][a-zA-Z0-9_]*)?$/;
     return paramPattern.test(str);
 }
-function isSingleRowResult(selectstmt, dbSchema) {
+function isSingleRowResult(selectstmt, fromColumns) {
     var _a, _b;
     const limit = checkLimit(selectstmt);
     if (limit === 1) {
@@ -1873,9 +2036,7 @@ function isSingleRowResult(selectstmt, dbSchema) {
     }
     const where_clause = simple_select_pramary.where_clause();
     if (where_clause) {
-        const tableName = getTableName(table_ref_list[0]);
-        const uniqueKeys = dbSchema.filter(col => col.table_name.toLowerCase() === tableName.name.toLowerCase()
-            && (col.column_key === 'PRI' || col.column_key === 'UNI'))
+        const uniqueKeys = fromColumns.filter(col => col.column_key === 'PRI' || col.column_key === 'UNI')
             .map(col => col.column_name);
         return isSingleRowResult_where(where_clause.a_expr(), uniqueKeys);
     }