typesql-cli 0.15.0-experimental.5 → 0.15.1

package/postgres-query-analyzer/traverse.js

@@ -7,7 +7,8 @@ const select_columns_1 = require("../mysql-query-analyzer/select-columns");
 function traverseSmt(stmt, dbSchema) {
     const traverseResult = {
         columnsNullability: [],
-        parametersNullability: []
+        parameters: [],
+        singleRow: false
     };
     const selectstmt = stmt.selectstmt();
     if (selectstmt) {
@@ -45,12 +46,16 @@ function traverseSelectstmt(selectstmt, dbSchema, fromColumns, 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);
+    //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 limit = checkLimit(selectstmt);
     return {
         queryType: 'Select',
+        multipleRowsResult,
         columnsNullability,
-        parametersNullability: traverseResult.parametersNullability,
+        parametersNullability: traverseResult.parameters.map(param => param.isNotNull),
         parameterList: paramIsListResult,
         limit
     };
@@ -112,6 +117,7 @@ function traverse_simple_select_intersect(simple_select_intersect, dbSchema, fro
     return [];
 }
 function traverse_simple_select_pramary(simple_select_pramary, dbSchema, parentFromColumns, traverseResult) {
+    var _a;
     const fromColumns = [];
     const from_clause = simple_select_pramary.from_clause();
     if (from_clause) {
@@ -125,6 +131,10 @@ function traverse_simple_select_pramary(simple_select_pramary, dbSchema, parentF
         const valuesColumns = traverse_values_clause(values_clause, dbSchema, parentFromColumns, traverseResult);
         return valuesColumns;
     }
+    const where_a_expr = (_a = simple_select_pramary.where_clause()) === null || _a === void 0 ? void 0 : _a.a_expr();
+    if (where_a_expr) {
+        traverse_a_expr(where_a_expr, dbSchema, parentFromColumns.concat(fromColumns), traverseResult);
+    }
     const filteredColumns = filterColumns_simple_select_pramary(simple_select_pramary, dbSchema, parentFromColumns.concat(fromColumns), traverseResult);
     return filteredColumns;
 }
@@ -153,12 +163,16 @@ function filterColumns_simple_select_pramary(simple_select_pramary, dbSchema, fr
     if (target_list_) {
         const target_list = target_list_.target_list();
         if (target_list) {
-            return filterColumns_target_list(target_list, dbSchema, fromColumns, traverseResult);
+            return traverse_target_list(target_list, dbSchema, fromColumns, traverseResult);
         }
     }
+    const target_list = simple_select_pramary.target_list();
+    if (target_list) {
+        return traverse_target_list(target_list, dbSchema, fromColumns, traverseResult);
+    }
     return [];
 }
-function filterColumns_target_list(target_list, dbSchema, fromColumns, traverseResult) {
+function traverse_target_list(target_list, dbSchema, fromColumns, traverseResult) {
     const columns = target_list.target_el_list().flatMap(target_el => {
         const fieldName = (0, select_columns_1.splitName)(target_el.getText());
         if (fieldName.name == '*') {
@@ -219,11 +233,11 @@ function traverse_expr_or(a_expr_or, dbSchema, fromColumns, traverseResult) {
     throw Error('traverse_expr_or -  Not expected:' + a_expr_or.getText());
 }
 function traverse_expr_and(a_expr_and, dbSchema, fromColumns, traverseResult) {
-    const a_expr_between = a_expr_and.a_expr_between_list()[0];
-    if (a_expr_between) {
-        return traverse_expr_between(a_expr_between, dbSchema, fromColumns, traverseResult);
-    }
-    throw Error('traverse_expr_and -  Not expected:' + a_expr_and.getText());
+    const result = a_expr_and.a_expr_between_list().map(a_expr_between => traverse_expr_between(a_expr_between, dbSchema, fromColumns, traverseResult));
+    return {
+        column_name: a_expr_and.getText(),
+        is_nullable: result.some(col => col.is_nullable)
+    };
 }
 function traverse_expr_between(a_expr_between, dbSchema, fromColumns, traverseResult) {
     const a_expr_in = a_expr_between.a_expr_in_list()[0];
@@ -234,10 +248,31 @@ function traverse_expr_between(a_expr_between, dbSchema, fromColumns, traverseRe
 }
 function traverse_expr_in(a_expr_in, dbSchema, fromColumns, traverseResult) {
     const a_expr_unary = a_expr_in.a_expr_unary_not();
+    let leftExprResult = undefined;
     if (a_expr_unary) {
-        return traverse_expr_unary(a_expr_unary, dbSchema, fromColumns, traverseResult);
+        leftExprResult = traverse_expr_unary(a_expr_unary, dbSchema, fromColumns, traverseResult);
+    }
+    const in_expr = a_expr_in.in_expr();
+    if (in_expr) {
+        traverse_in_expr(in_expr, dbSchema, fromColumns, traverseResult);
+    }
+    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
+    };
+}
+function traverse_in_expr(in_expr, dbSchema, fromColumns, 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);
+    }
+    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);
+        });
     }
-    throw Error('traverse_expr_in -  Not expected:' + a_expr_in.getText());
 }
 function traverse_expr_unary(a_expr_unary, dbSchema, fromColumns, traverseResult) {
     const a_expr_isnull = a_expr_unary.a_expr_isnull();
@@ -261,16 +296,24 @@ function traverse_expr_is_not(a_expr_is_not, dbSchema, fromColumns, traverseResu
     throw Error('traverse_expr_is_not -  Not expected:' + a_expr_is_not.getText());
 }
 function traverse_expr_compare(a_expr_compare, dbSchema, fromColumns, traverseResult) {
-    const a_expr_like = a_expr_compare.a_expr_like_list()[0];
-    if (a_expr_like) {
-        return traverse_expr_like(a_expr_like, dbSchema, fromColumns, 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));
+        return {
+            column_name: a_expr_compare.getText(),
+            is_nullable: result.some(col => col.is_nullable)
+        };
     }
     throw Error('traverse_expr_compare -  Not expected:' + a_expr_compare.getText());
 }
 function traverse_expr_like(a_expr_like, dbSchema, fromColumns, traverseResult) {
-    const a_expr_qual_op = a_expr_like.a_expr_qual_op_list()[0];
-    if (a_expr_qual_op) {
-        return traverse_expr_qual_op(a_expr_qual_op, dbSchema, fromColumns, 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));
+        return {
+            column_name: a_expr_like.getText(),
+            is_nullable: result.some(col => col.is_nullable)
+        };
     }
     throw Error('traverse_expr_like -  Not expected:' + a_expr_like.getText());
 }
@@ -346,13 +389,17 @@ function traverse_expr_typecast(a_expr_typecast, dbSchema, fromColumns, traverse
     }
     throw Error('traverse_expr_typecast -  Not expected:' + a_expr_typecast.getText());
 }
+function traverseColumnRef(columnref, fromColumns) {
+    const fieldName = (0, select_columns_1.splitName)(columnref.getText());
+    const col = findColumn(fieldName, fromColumns);
+    return col;
+}
 function traversec_expr(c_expr, dbSchema, fromColumns, traverseResult) {
     var _a, _b;
     if (c_expr instanceof PostgreSQLParser_1.C_expr_exprContext) {
         const columnref = c_expr.columnref();
         if (columnref) {
-            const fieldName = (0, select_columns_1.splitName)(columnref.getText());
-            const col = findColumn(fieldName, fromColumns);
+            const col = traverseColumnRef(columnref, fromColumns);
             return col;
         }
         const aexprconst = c_expr.aexprconst();
@@ -364,7 +411,10 @@ function traversec_expr(c_expr, dbSchema, fromColumns, traverseResult) {
             };
         }
         if (c_expr.PARAM()) {
-            traverseResult.parametersNullability.push(true);
+            traverseResult.parameters.push({
+                paramIndex: c_expr.start.start,
+                isNotNull: true
+            });
             return {
                 column_name: c_expr.PARAM().getText(),
                 is_nullable: false
@@ -429,15 +479,32 @@ function excludeColumns(fromColumns, excludeList) {
 function traversec_expr_case(c_expr_case, dbSchema, fromColumns, 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, dbSchema, fromColumns, 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;
     return elseIsNotNull && whenIsNotNull;
 }
 function traversewhen_clause(when_clause, dbSchema, fromColumns, 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], dbSchema, fromColumns, traverseResult);
+        const thenExprResult = traverse_a_expr(thenExpr, dbSchema, fromColumns, traverseResult);
+        return thenExprResult;
+    });
+    return whenExprResult.every(res => res);
+}
+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, dbSchema, fromColumns, traverseResult) {
     var _a;
@@ -471,7 +538,7 @@ function traversefunc_expr_common_subexpr(func_expr_common_subexpr, dbSchema, fr
         const result = func_arg_list.map(func_arg_expr => {
             const paramResult = traverse_a_expr(func_arg_expr, dbSchema, fromColumns, traverseResult);
             if (isParameter(paramResult.column_name)) {
-                traverseResult.parametersNullability[traverseResult.parametersNullability.length - 1] = false;
+                traverseResult.parameters[traverseResult.parameters.length - 1].isNotNull = false;
                 paramResult.is_nullable = true;
             }
             return paramResult;
@@ -519,11 +586,11 @@ function traverse_table_ref(table_ref, dbSchema, fromColumns, traverseResult) {
     const allColumns = [];
     const relation_expr = table_ref.relation_expr();
     const aliasClause = table_ref.alias_clause();
-    const alias = aliasClause ? aliasClause.getText() : undefined;
+    const alias = aliasClause ? aliasClause.colid().getText() : undefined;
     if (relation_expr) {
         const tableName = traverse_relation_expr(relation_expr, dbSchema);
-        const tableNameWithAlias = alias ? alias : tableName;
-        const fromColumnsResult = fromColumns.concat(dbSchema).filter(col => col.table_name === tableName).map(col => (Object.assign(Object.assign({}, col), { table_name: tableNameWithAlias })));
+        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 })));
         allColumns.push(...fromColumnsResult);
     }
     const table_ref_list = table_ref.table_ref_list();
@@ -572,11 +639,19 @@ function traverse_relation_expr(relation_expr, dbSchema) {
     return name;
 }
 function traverse_qualified_name(qualified_name, dbSchema) {
-    const colid = qualified_name.colid();
-    if (colid) {
-        return traverse_colid(colid, dbSchema);
+    var _a, _b;
+    const colid_name = qualified_name.colid() ? traverse_colid(qualified_name.colid(), dbSchema) : '';
+    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 {
+            name: ((_b = indirection_el_list[0].attr_name()) === null || _b === void 0 ? void 0 : _b.getText()) || '',
+            alias: colid_name
+        };
     }
-    return '';
+    return {
+        name: colid_name,
+        alias: ''
+    };
 }
 function traverse_colid(colid, dbSchema) {
     const identifier = colid.identifier();
@@ -626,6 +701,11 @@ function paramIsList(c_expr) {
     return in_expr_list instanceof PostgreSQLParser_1.In_expr_listContext;
 }
 function traverseInsertstmt(insertstmt, dbSchema) {
+    const traverseResult = {
+        columnsNullability: [],
+        parameters: [],
+        singleRow: false
+    };
     const insert_target = insertstmt.insert_target();
     const tableName = insert_target.getText();
     const insertColumns = dbSchema.filter(col => col.table_name === tableName);
@@ -634,82 +714,115 @@ function traverseInsertstmt(insertstmt, dbSchema) {
         .insert_column_item_list()
         .map(insert_column_item => traverse_insert_column_item(insert_column_item, insertColumns));
     const selectstmt = insert_rest.selectstmt();
-    const parametersNullability = traverse_insert_select_stmt(selectstmt, dbSchema, insertColumnsList);
-    return {
+    traverse_insert_select_stmt(selectstmt, dbSchema, 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));
+    }
+    const returning_clause = insertstmt.returning_clause();
+    const returninColumns = returning_clause ? traverse_target_list(returning_clause.target_list(), dbSchema, insertColumns, traverseResult) : [];
+    const result = {
         queryType: 'Insert',
-        parametersNullability,
-        columnsNullability: [],
+        multipleRowsResult: false,
+        parametersNullability: traverseResult.parameters.map(param => param.isNotNull),
+        columnsNullability: returninColumns.map(col => !col.is_nullable),
         parameterList: []
     };
+    if (returning_clause) {
+        result.returning = true;
+    }
+    return result;
 }
-function traverse_insert_select_stmt(selectstmt, dbSchema, insertColumnlist) {
-    var _a, _b, _c, _d;
+function traverse_insert_select_stmt(selectstmt, dbSchema, insertColumnlist, 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) {
         const simple_select_pramary = (_d = simple_select === null || simple_select === void 0 ? void 0 : simple_select.simple_select_pramary_list()) === null || _d === void 0 ? void 0 : _d[0];
         if (simple_select_pramary) {
-            return simple_select_pramary.values_clause().expr_list_list()
-                .flatMap(expr_list => traverse_insert_a_expr_list(expr_list, dbSchema, insertColumnlist));
+            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));
+            }
+            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) : [];
+                target_list.target_el_list().forEach((target_el, index) => {
+                    const targetResult = isNotNull_target_el(target_el, dbSchema, fromColumns, traverseResult);
+                    if (isParameter(targetResult.column_name)) {
+                        traverseResult.parameters.at(-1).isNotNull = !insertColumnlist[index].is_nullable;
+                    }
+                });
+            }
         }
     }
-    return [];
 }
-function traverse_insert_a_expr_list(expr_list, dbSchema, insertColumns) {
-    const parametersNullability = [];
+function traverse_insert_a_expr_list(expr_list, dbSchema, insertColumns, traverseResult) {
     expr_list.a_expr_list().forEach((a_expr, index) => {
-        const traverseResult = {
-            columnsNullability: [],
-            parametersNullability: []
-        };
         const result = traverse_a_expr(a_expr, dbSchema, insertColumns, traverseResult);
         if (isParameter(result.column_name)) {
-            parametersNullability.push(!insertColumns[index].is_nullable);
-        }
-        else {
-            parametersNullability.push(...traverseResult.parametersNullability);
+            traverseResult.parameters.at(-1).isNotNull = !insertColumns[index].is_nullable;
         }
     });
-    return parametersNullability;
 }
 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 returninColumns = returning_clause ? traverse_target_list(returning_clause.target_list(), dbSchema, deleteColumns, traverseResult) : [];
+    const result = {
         queryType: 'Delete',
-        parametersNullability: traverseResult.parametersNullability,
-        columnsNullability: [],
+        multipleRowsResult: false,
+        parametersNullability: traverseResult.parameters.map(param => param.isNotNull),
+        columnsNullability: returninColumns.map(col => !col.is_nullable),
         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);
     updatestmt.set_clause_list().set_clause_list()
-        .map(set_clause => traverse_set_clause(set_clause, dbSchema, updateColumns, traverseResult));
-    const dataParameters = traverseResult.parametersNullability;
+        .forEach(set_clause => traverse_set_clause(set_clause, dbSchema, updateColumns, 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);
     }
-    const whereParameters = traverseResult.parametersNullability.slice(dataParameters.length);
-    return {
+    const whereParameters = traverseResult.parameters.slice(parametersBefore);
+    const returning_clause = updatestmt.returning_clause();
+    const returninColumns = returning_clause ? traverse_target_list(returning_clause.target_list(), dbSchema, updateColumns, traverseResult) : [];
+    const result = {
         queryType: 'Update',
-        parametersNullability: traverseResult.parametersNullability,
-        columnsNullability: [],
+        multipleRowsResult: false,
+        parametersNullability: traverseResult.parameters.slice(0, parametersBefore).map(param => param.isNotNull),
+        columnsNullability: returninColumns.map(col => !col.is_nullable),
         parameterList: [],
-        whereParamtersNullability: whereParameters
+        whereParamtersNullability: whereParameters.map(param => param.isNotNull)
     };
+    if (returning_clause) {
+        result.returning = true;
+    }
+    return result;
 }
 function traverse_set_clause(set_clause, dbSchema, updateColumns, traverseResult) {
     const set_target = set_clause.set_target();
     const columnName = (0, select_columns_1.splitName)(set_target.getText());
     const column = findColumn(columnName, updateColumns);
     const a_expr = set_clause.a_expr();
-    const a_exprResult = traverse_a_expr(a_expr, dbSchema, updateColumns, traverseResult);
+    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);
     if (isParameter(a_exprResult.column_name)) {
-        traverseResult.parametersNullability[traverseResult.parametersNullability.length - 1] = !column.is_nullable;
+        traverseResult.parameters[traverseResult.parameters.length - 1].isNotNull = !column.is_nullable;
     }
-    return !column.is_nullable;
 }
 function traverse_insert_column_item(insert_column_item, dbSchema) {
     const colid = insert_column_item.colid();
@@ -905,20 +1018,10 @@ function isNotNull_c_expr(c_expr, field) {
     }
     return false;
 }
-function checkLimit(selectstmt) {
-    const select_no_parens = selectstmt.select_no_parens();
-    if (select_no_parens) {
-        return checkLimit_select_no_parens(select_no_parens);
-    }
-    const select_with_parens = selectstmt.select_with_parens();
-    if (select_with_parens) {
-        return checkLimit_select_with_parens(select_with_parens);
-    }
-    return undefined;
-}
 function checkLimit_select_no_parens(select_no_parens) {
     var _a, _b, _c;
-    return +((_c = (_b = (_a = select_no_parens.select_limit()) === null || _a === void 0 ? void 0 : _a.limit_clause()) === null || _b === void 0 ? void 0 : _b.select_limit_value()) === null || _c === void 0 ? void 0 : _c.getText());
+    const limitText = (_c = (_b = (_a = select_no_parens.select_limit()) === null || _a === void 0 ? void 0 : _a.limit_clause()) === null || _b === void 0 ? void 0 : _b.select_limit_value()) === null || _c === void 0 ? void 0 : _c.getText();
+    return limitText ? +limitText : undefined;
 }
 function checkLimit_select_with_parens(select_with_parens) {
     return checkLimit(select_with_parens);
@@ -928,4 +1031,203 @@ function isParameter(str) {
     const paramPattern = /^\$[0-9]+(::[a-zA-Z_][a-zA-Z0-9_]*)?$/;
     return paramPattern.test(str);
 }
+function isSingleRowResult(selectstmt, dbSchema) {
+    var _a;
+    const limit = checkLimit(selectstmt);
+    if (limit === 1) {
+        return true;
+    }
+    const select_no_parens = selectstmt.select_no_parens();
+    const simple_select_pramary_list = (_a = select_no_parens.select_clause()
+        .simple_select_intersect_list()) === null || _a === void 0 ? void 0 : _a[0].simple_select_pramary_list();
+    if (simple_select_pramary_list.length > 1) {
+        return false;
+    }
+    const simple_select_pramary = simple_select_pramary_list[0];
+    const from_clause = simple_select_pramary.from_clause();
+    if (!from_clause) {
+        const hasSetReturningFunction = simple_select_pramary.target_list_().target_list().target_el_list().some(target_el => isSetReturningFunction_target_el(target_el));
+        return !hasSetReturningFunction;
+    }
+    if (!simple_select_pramary.group_clause()) {
+        const agreegateFunction = hasAggregateFunction(simple_select_pramary);
+        if (agreegateFunction) {
+            return true;
+        }
+    }
+    const table_ref_list = from_clause.from_list().table_ref_list();
+    if (table_ref_list.length > 1) {
+        return false;
+    }
+    if (table_ref_list[0].JOIN_list().length > 0 || table_ref_list[0].select_with_parens() != null) {
+        return false;
+    }
+    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'))
+        .map(col => col.column_name);
+    const where_clause = simple_select_pramary.where_clause();
+    if (where_clause) {
+        return isSingleRowResult_where(where_clause.a_expr(), uniqueKeys);
+    }
+    return false;
+}
+function hasAggregateFunction(simple_select_pramary) {
+    const target_list_ = simple_select_pramary.target_list_();
+    if (target_list_) {
+        return target_list_.target_list().target_el_list().some(target_el => isAggregateFunction_target_el(target_el));
+    }
+    const target_list = simple_select_pramary.target_list();
+    return target_list.target_el_list().some(target_el => isAggregateFunction_target_el(target_el));
+}
+function getTableName(table_ref) {
+    const relation_expr = table_ref.relation_expr();
+    const tableName = relation_expr.qualified_name().getText();
+    const aliasClause = table_ref.alias_clause();
+    const tableAlias = aliasClause ? aliasClause.colid().getText() : '';
+    return {
+        name: tableName,
+        alias: tableAlias
+    };
+}
+function isAggregateFunction_target_el(target_el) {
+    if (target_el instanceof PostgreSQLParser_1.Target_labelContext) {
+        const c_expr_list = collectContextsOfType(target_el, PostgreSQLParser_1.Func_exprContext);
+        const aggrFunction = c_expr_list.some(func_expr => isAggregateFunction_c_expr(func_expr));
+        return aggrFunction;
+    }
+    return false;
+}
+// SELECT distinct '''' ||  p.proname || '''' || ',' as aggregate_function
+// FROM pg_catalog.pg_proc p
+// JOIN pg_catalog.pg_aggregate a ON a.aggfnoid = p.oid
+// ORDER BY  aggregate_function;
+const aggregateFunctions = new Set([
+    'array_agg',
+    'avg',
+    'bit_and',
+    'bit_or',
+    'bool_and',
+    'bool_or',
+    'corr',
+    'count',
+    'covar_pop',
+    'covar_samp',
+    'cume_dist',
+    'dense_rank',
+    'every',
+    'json_agg',
+    'json_object_agg',
+    'jsonb_agg',
+    'jsonb_object_agg',
+    'max',
+    'min',
+    'mode',
+    'percent_rank',
+    'percentile_cont',
+    'percentile_disc',
+    'rank',
+    'regr_avgx',
+    'regr_avgy',
+    'regr_count',
+    'regr_intercept',
+    'regr_r2',
+    'regr_slope',
+    'regr_sxx',
+    'regr_sxy',
+    'regr_syy',
+    'stddev',
+    'stddev_pop',
+    'stddev_samp',
+    'string_agg',
+    'sum',
+    'var_pop',
+    'var_samp',
+    'variance',
+    'xmlagg'
+]);
+function isAggregateFunction_c_expr(func_expr) {
+    var _a, _b, _c;
+    const funcName = (_c = (_b = (_a = func_expr === null || func_expr === void 0 ? void 0 : func_expr.func_application()) === null || _a === void 0 ? void 0 : _a.func_name()) === null || _b === void 0 ? void 0 : _b.getText()) === null || _c === void 0 ? void 0 : _c.toLowerCase();
+    return aggregateFunctions.has(funcName);
+}
+function isSetReturningFunction_target_el(target_el) {
+    if (target_el instanceof PostgreSQLParser_1.Target_labelContext) {
+        const c_expr_list = collectContextsOfType(target_el, PostgreSQLParser_1.Func_exprContext);
+        const setReturningFunction = c_expr_list.some(func_expr => isSetReturningFunction_c_expr(func_expr));
+        return setReturningFunction;
+    }
+    return false;
+}
+function isSetReturningFunction_c_expr(func_expr) {
+    var _a, _b, _c;
+    const funcName = (_c = (_b = (_a = func_expr === null || func_expr === void 0 ? void 0 : func_expr.func_application()) === null || _a === void 0 ? void 0 : _a.func_name()) === null || _b === void 0 ? void 0 : _b.getText()) === null || _c === void 0 ? void 0 : _c.toLowerCase();
+    return funcName === 'generate_series';
+}
+function isSingleRowResult_where(a_expr, uniqueKeys) {
+    var _a, _b;
+    const a_expr_or_list = ((_b = (_a = a_expr.a_expr_qual()) === null || _a === void 0 ? void 0 : _a.a_expr_lessless()) === null || _b === void 0 ? void 0 : _b.a_expr_or_list()) || [];
+    if (a_expr_or_list.length > 1 || a_expr_or_list[0].OR_list().length > 0) {
+        return false;
+    }
+    const someInSingleRow = a_expr_or_list[0].a_expr_and_list().some(a_expr_and => {
+        const a = isSingleRowResult_a_expr_and(a_expr_and, uniqueKeys);
+        return a;
+    });
+    return someInSingleRow;
+}
+function isSingleRowResult_a_expr_and(a_expr_and, uniqueKeys) {
+    const a_expr_between_list = a_expr_and.a_expr_between_list();
+    if (a_expr_between_list && a_expr_between_list.length > 0) {
+        return a_expr_between_list.some(a_expr_between => isSingleRowResult_a_expr_between(a_expr_between, uniqueKeys));
+    }
+    return false;
+}
+function isSingleRowResult_a_expr_between(a_expr_between, uniqueKeys) {
+    const isSingleRow = a_expr_between.a_expr_in_list().every(a_expr_in => isSingleRowResult_a_expr_in(a_expr_in, uniqueKeys));
+    return isSingleRow;
+}
+function isSingleRowResult_a_expr_in(a_expr_in, uniqueKeys) {
+    var _a, _b, _c;
+    const a_expr_compare = (_c = (_b = (_a = a_expr_in.a_expr_unary_not()) === null || _a === void 0 ? void 0 : _a.a_expr_isnull()) === null || _b === void 0 ? void 0 : _b.a_expr_is_not()) === null || _c === void 0 ? void 0 : _c.a_expr_compare();
+    if (a_expr_compare) {
+        if (a_expr_compare.EQUAL() != null) {
+            const a_expr_like_list = a_expr_compare.a_expr_like_list();
+            if (a_expr_like_list && a_expr_like_list.length == 2) {
+                const left = a_expr_like_list[0];
+                const right = a_expr_like_list[1];
+                const result = (isUniqueColumn(left, uniqueKeys) + isUniqueColumn(right, uniqueKeys));
+                return result == 1;
+            }
+        }
+        ;
+    }
+    return false;
+}
+//1 = yes
+//0 = no
+function isUniqueColumn(a_expr_like, uniqueKeys) {
+    var _a, _b;
+    const c_expr = (_b = (_a = a_expr_like.a_expr_qual_op_list()) === null || _a === void 0 ? void 0 : _a[0].a_expr_unary_qualop_list()) === null || _b === void 0 ? void 0 : _b[0].a_expr_add().a_expr_mul_list()[0].a_expr_caret_list()[0].a_expr_unary_sign_list()[0].a_expr_at_time_zone().a_expr_collate().a_expr_typecast().c_expr();
+    if (c_expr instanceof PostgreSQLParser_1.C_expr_exprContext) {
+        const columnref = c_expr.columnref();
+        if (columnref) {
+            const fieldName = (0, select_columns_1.splitName)(columnref.getText());
+            // const col = traverseColumnRef(columnref, dbSchema);
+            return uniqueKeys.includes(fieldName.name) ? 1 : 0;
+        }
+    }
+    return 0;
+}
+function checkLimit(selectstmt) {
+    const select_no_parens = selectstmt.select_no_parens();
+    if (select_no_parens) {
+        return checkLimit_select_no_parens(select_no_parens);
+    }
+    const select_with_parens = selectstmt.select_with_parens();
+    if (select_with_parens) {
+        return checkLimit_select_with_parens(select_with_parens);
+    }
+    return undefined;
+}
 //# sourceMappingURL=traverse.js.map