typesql-cli 0.8.0-alpha.5 → 0.8.0-alpha.7

package/sqlite-query-analyzer/traverse.js

@@ -8,7 +8,26 @@ function traverse_Sql_stmtContext(sql_stmt, traverseContext) {
     const select_stmt = sql_stmt.select_stmt();
     if (select_stmt) {
         const queryResult = traverse_select_stmt(select_stmt, traverseContext);
-        return queryResult;
+        return {
+            queryType: 'Select',
+            columns: queryResult.columns,
+            multipleRowsResult: isMultipleRowResult(select_stmt, queryResult.fromColumns),
+        };
+    }
+    const insert_stmt = sql_stmt.insert_stmt();
+    if (insert_stmt) {
+        const insertResult = traverse_insert_stmt(insert_stmt, traverseContext);
+        return insertResult;
+    }
+    const update_stmt = sql_stmt.update_stmt();
+    if (update_stmt) {
+        const updateResult = traverse_update_stmt(update_stmt, traverseContext);
+        return updateResult;
+    }
+    const delete_stmt = sql_stmt.delete_stmt();
+    if (delete_stmt) {
+        const deleteResult = traverse_delete_stmt(delete_stmt, traverseContext);
+        return deleteResult;
     }
     throw Error("traverse_Sql_stmtContext");
 }
@@ -36,7 +55,6 @@ function traverse_select_stmt(select_stmt, traverseContext) {
     const querySpecResult = select_coreList.map(select_core => {
         const columnsResult = [];
         const listType = [];
-        const columnNullability = [];
         const table_or_subquery = select_core.table_or_subquery_list();
         if (table_or_subquery) {
             const fields = traverse_table_or_subquery(table_or_subquery, traverseContext);
@@ -56,8 +74,12 @@ function traverse_select_stmt(select_stmt, traverseContext) {
                 columnsResult.forEach(col => {
                     if (!tableName || (0, select_columns_1.includeColumn)(col, tableName)) {
                         const columnType = (0, collect_constraints_1.createColumnType)(col);
-                        listType.push(columnType);
-                        columnNullability.push(col.notNull);
+                        listType.push({
+                            name: columnType.name,
+                            type: columnType,
+                            notNull: col.notNull,
+                            table: col.tableAlias || col.table
+                        });
                     }
                 });
             }
@@ -65,12 +87,11 @@ function traverse_select_stmt(select_stmt, traverseContext) {
             const alias = (_b = result_column.column_alias()) === null || _b === void 0 ? void 0 : _b.getText();
             if (expr) {
                 const exprType = traverse_expr(expr, Object.assign(Object.assign({}, traverseContext), { fromColumns: columnsResult }));
-                if (exprType.kind == 'TypeVar') {
+                if (exprType.type.kind == 'TypeVar') {
                     if (alias) {
                         exprType.name = alias;
                     }
                     listType.push(exprType);
-                    columnNullability.push(inferNotNull_expr(expr, columnsResult));
                 }
             }
         });
@@ -78,17 +99,8 @@ function traverse_select_stmt(select_stmt, traverseContext) {
         whereList.forEach(where => {
             traverse_expr(where, Object.assign(Object.assign({}, traverseContext), { fromColumns: columnsResult }));
         });
-        const columns = listType.map((t, index) => {
-            const resultType = {
-                name: t.name,
-                type: t,
-                notNull: columnNullability[index],
-                table: t.table || ''
-            };
-            return resultType;
-        });
         const querySpecification = {
-            columns,
+            columns: listType,
             fromColumns: columnsResult //TODO - return isMultipleRowResult instead
         };
         return querySpecification;
@@ -141,24 +153,50 @@ function traverse_expr(expr, traverseContext) {
     var _a, _b;
     const function_name = (_a = expr.function_name()) === null || _a === void 0 ? void 0 : _a.getText().toLowerCase();
     if (function_name == 'sum' || function_name == 'avg') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'NUMERIC');
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), function_name == 'sum' ? 'NUMERIC' : 'REAL');
         const sumParamExpr = expr.expr(0);
         const paramType = traverse_expr(sumParamExpr, traverseContext);
-        if (paramType.kind == 'TypeVar') {
+        if (paramType.type.kind == 'TypeVar') {
             functionType.table = paramType.table;
         }
-        return functionType;
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: paramType.notNull,
+            table: functionType.table || ''
+        };
+    }
+    if (function_name == 'min' || function_name == 'max') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+        const sumParamExpr = expr.expr(0);
+        const paramType = traverse_expr(sumParamExpr, traverseContext);
+        traverseContext.constraints.push({
+            expression: expr.getText(),
+            type1: functionType,
+            type2: paramType.type
+        });
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: paramType.notNull,
+            table: functionType.table || ''
+        };
     }
     if (function_name == 'count') {
         const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
         if (expr.expr_list().length == 1) {
             const sumParamExpr = expr.expr(0);
             const paramType = traverse_expr(sumParamExpr, traverseContext);
-            if (paramType.kind == 'TypeVar') {
+            if (paramType.type.kind == 'TypeVar') {
                 functionType.table = paramType.table;
             }
         }
-        return functionType;
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: true,
+            table: functionType.table || ''
+        };
     }
     if (function_name == 'concat') {
         const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT');
@@ -167,88 +205,243 @@ function traverse_expr(expr, traverseContext) {
             traverseContext.constraints.push({
                 expression: expr.getText(),
                 type1: functionType,
-                type2: paramType
+                type2: paramType.type
             });
-            if (paramType.kind == 'TypeVar') {
+            if (paramType.type.kind == 'TypeVar') {
                 functionType.table = paramType.table;
             }
         });
-        return functionType;
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: true,
+            table: functionType.table || ''
+        };
+    }
+    if (function_name == 'coalesce') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+        const paramTypes = expr.expr_list().map(paramExpr => {
+            const paramType = traverse_expr(paramExpr, traverseContext);
+            traverseContext.constraints.push({
+                expression: expr.getText(),
+                type1: functionType,
+                type2: paramType.type
+            });
+            return paramType;
+        });
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: paramTypes.some(param => param.notNull),
+            table: functionType.table || ''
+        };
+    }
+    if (function_name == 'strftime') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT');
+        const paramExpr = expr.expr(1);
+        const paramType = traverse_expr(paramExpr, traverseContext);
+        paramType.notNull = true;
+        traverseContext.constraints.push({
+            expression: paramExpr.getText(),
+            type1: (0, collect_constraints_1.freshVar)(paramExpr.getText(), 'DATE'),
+            type2: paramType.type
+        });
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: false,
+            table: functionType.table || ''
+        };
+    }
+    if (function_name == 'date' || function_name == 'time' || function_name == 'datetime') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT');
+        const paramExpr = expr.expr(0);
+        const paramType = traverse_expr(paramExpr, traverseContext);
+        paramType.notNull = true;
+        traverseContext.constraints.push({
+            expression: paramExpr.getText(),
+            type1: (0, collect_constraints_1.freshVar)(paramExpr.getText(), 'DATE'),
+            type2: paramType.type
+        });
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: false,
+            table: functionType.table || ''
+        };
+    }
+    if (function_name == 'ifnull') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+        const paramTypes = expr.expr_list().map(paramExpr => {
+            const paramType = traverse_expr(paramExpr, traverseContext);
+            if (paramType.name == '?') {
+                paramType.notNull = false;
+            }
+            traverseContext.constraints.push({
+                expression: expr.getText(),
+                type1: functionType,
+                type2: paramType.type
+            });
+            return paramType;
+        });
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: paramTypes.every(param => param.notNull),
+            table: functionType.table || ''
+        };
     }
     if (function_name) {
         throw Error('traverse_expr: function not supported:' + function_name);
     }
     const column_name = expr.column_name();
     if (column_name) {
-        const fieldName = (0, select_columns_1.splitName)(column_name.getText());
-        const column = (0, select_columns_1.findColumn)(fieldName, traverseContext.fromColumns);
-        const typeVar = (0, collect_constraints_1.freshVar)(column.columnName, column.columnType.type, column.tableAlias || column.table);
-        return typeVar;
+        const type = traverse_column_name(column_name, traverseContext);
+        return type;
     }
     const literal = expr.literal_value();
     if (literal) {
         if (literal.STRING_LITERAL()) {
-            return (0, collect_constraints_1.freshVar)(literal.getText(), 'TEXT');
+            const type = (0, collect_constraints_1.freshVar)(literal.getText(), 'TEXT');
+            return {
+                name: type.name,
+                type: type,
+                notNull: true,
+                table: type.table || ''
+            };
         }
         if (literal.NUMERIC_LITERAL()) {
-            return (0, collect_constraints_1.freshVar)(literal.getText(), 'INTEGER');
+            const type = (0, collect_constraints_1.freshVar)(literal.getText(), 'INTEGER');
+            return {
+                name: type.name,
+                type: type,
+                notNull: true,
+                table: type.table || ''
+            };
         }
-        return (0, collect_constraints_1.freshVar)(literal.getText(), '?');
+        const type = (0, collect_constraints_1.freshVar)(literal.getText(), '?');
+        return {
+            name: type.name,
+            type: type,
+            notNull: true,
+            table: type.table || ''
+        };
     }
     const parameter = expr.BIND_PARAMETER();
     if (parameter) {
         const param = (0, collect_constraints_1.freshVar)('?', '?');
-        traverseContext.parameters.push(param);
-        return param;
+        const type = {
+            name: param.name,
+            type: param,
+            notNull: false,
+            table: param.table || ''
+        };
+        traverseContext.parameters.push(type);
+        return type;
     }
     if (expr.STAR() || expr.DIV() || expr.MOD()) {
         const exprLeft = expr.expr(0);
         const exprRight = expr.expr(1);
         const typeLeft = traverse_expr(exprLeft, traverseContext);
-        return (0, collect_constraints_1.freshVar)(expr.getText(), 'tinyint');
+        const typeRight = traverse_expr(exprRight, traverseContext);
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+        return {
+            name: type.name,
+            type: type,
+            notNull: typeLeft.notNull && typeRight.notNull,
+            table: type.table || ''
+        };
+    }
+    if (expr.PLUS() || expr.MINUS()) {
+        const exprLeft = expr.expr(0);
+        const exprRight = expr.expr(1);
+        const typeLeft = traverse_expr(exprLeft, traverseContext);
+        const typeRight = traverse_expr(exprRight, traverseContext);
+        return Object.assign(Object.assign({}, typeRight), { notNull: typeLeft.notNull && typeRight.notNull });
     }
     if (expr.LT2() || expr.GT2() || expr.AMP() || expr.PIPE() || expr.LT() || expr.LT_EQ() || expr.GT() || expr.GT_EQ()) {
         const exprLeft = expr.expr(0);
         const exprRight = expr.expr(1);
         const typeLeft = traverse_expr(exprLeft, traverseContext);
         const typeRight = traverse_expr(exprRight, traverseContext);
+        if (typeLeft.name == '?') {
+            typeLeft.notNull = true;
+        }
+        if (typeRight.name == '?') {
+            typeRight.notNull = true;
+        }
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: typeLeft,
-            type2: typeRight
+            type1: typeLeft.type,
+            type2: typeRight.type
         });
-        return (0, collect_constraints_1.freshVar)(expr.getText(), 'tinyint');
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+        return {
+            name: type.name,
+            type: type,
+            notNull: true,
+            table: type.table || ''
+        };
+    }
+    if (expr.IS_()) { //is null/is not null
+        const expr_ = expr.expr(0);
+        traverse_expr(expr_, traverseContext);
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+        return {
+            name: type.name,
+            type: type,
+            notNull: true,
+            table: type.table || ''
+        };
     }
     if (expr.ASSIGN()) { //=
         const exprLeft = expr.expr(0);
         const exprRight = expr.expr(1);
         const typeLeft = traverse_expr(exprLeft, traverseContext);
         const typeRight = traverse_expr(exprRight, traverseContext);
+        if (typeLeft.name == '?') {
+            typeLeft.notNull = true;
+        }
+        if (typeRight.name == '?') {
+            typeRight.notNull = true;
+        }
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: typeLeft,
-            type2: typeRight
+            type1: typeLeft.type,
+            type2: typeRight.type
         });
-        return (0, collect_constraints_1.freshVar)(expr.getText(), 'tinyint');
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+        return {
+            name: type.name,
+            type: type,
+            notNull: true,
+            table: type.table || ''
+        };
     }
     if (expr.BETWEEN_()) {
         const exprType = traverse_expr(expr.expr(0), traverseContext);
         const between1 = traverse_expr(expr.expr(1), traverseContext);
         const between2 = traverse_expr(expr.expr(2), traverseContext);
+        if (between1.name == '?') {
+            between1.notNull = true;
+        }
+        if (between2.name == '?') {
+            between2.notNull = true;
+        }
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: exprType,
-            type2: between1
+            type1: exprType.type,
+            type2: between1.type
         });
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: exprType,
-            type2: between2
+            type1: exprType.type,
+            type2: between2.type
         });
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: between1,
-            type2: between2
+            type1: between1.type,
+            type2: between2.type
         });
         return exprType;
     }
@@ -267,39 +460,58 @@ function traverse_expr(expr, traverseContext) {
                 const typeRight = traverse_expr(exprRight, traverseContext);
                 traverseContext.constraints.push({
                     expression: expr.getText(),
-                    type1: typeLeft,
-                    type2: typeRight
+                    type1: typeLeft.type,
+                    type2: typeRight.type
                 });
             }
         });
-        return (0, collect_constraints_1.freshVar)(expr.getText(), 'tinyint');
-    }
-    if (expr.OPEN_PAR() && expr.CLOSE_PAR()) {
-        expr.expr_list().forEach(innerExpr => {
-            traverse_expr(innerExpr, traverseContext);
-        });
-        return (0, collect_constraints_1.freshVar)(expr.getText(), 'tinyint');
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+        return {
+            name: type.name,
+            type: type,
+            notNull: true,
+            table: type.table || ''
+        };
     }
     const select_stmt = expr.select_stmt();
     if (select_stmt) {
         const subQueryType = traverse_select_stmt(select_stmt, traverseContext);
-        return Object.assign(Object.assign({}, subQueryType.columns[0].type), { table: '' });
+        const type = Object.assign(Object.assign({}, subQueryType.columns[0].type), { table: '' });
+        return {
+            name: type.name,
+            type: type,
+            notNull: subQueryType.columns[0].notNull,
+            table: type.table || ''
+        };
+    }
+    if (expr.OPEN_PAR() && expr.CLOSE_PAR()) {
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+        const exprTypes = expr.expr_list().map(innerExpr => {
+            const exprType = traverse_expr(innerExpr, traverseContext);
+            traverseContext.constraints.push({
+                expression: innerExpr.getText(),
+                type1: exprType.type,
+                type2: type
+            });
+            return exprType;
+        });
+        return {
+            name: type.name,
+            type: type,
+            notNull: exprTypes.every(type => type.notNull),
+            table: type.table || ''
+        };
     }
     if (expr.CASE_()) {
         const resultTypes = []; //then and else
         const whenTypes = [];
         expr.expr_list().forEach((expr_, index) => {
             const type = traverse_expr(expr_, traverseContext);
-            if (expr_.WHEN__list() || expr_.THEN__list()) {
-                if (index % 2 == 0) {
-                    whenTypes.push(type);
-                }
-                else {
-                    resultTypes.push(type);
-                }
+            if (index % 2 == 0 && (!expr.ELSE_() || index < expr.expr_list().length - 1)) {
+                whenTypes.push(type.type);
             }
-            if (expr_.ELSE_()) {
-                resultTypes.push(type);
+            else {
+                resultTypes.push(type.type);
             }
         });
         resultTypes.forEach((resultType, index) => {
@@ -311,26 +523,35 @@ function traverse_expr(expr, traverseContext) {
                 });
             }
         });
-        return resultTypes[0];
+        whenTypes.forEach((whenType) => {
+            traverseContext.constraints.push({
+                expression: expr.getText(),
+                type1: (0, collect_constraints_1.freshVar)('INTEGER', 'INTEGER'),
+                type2: whenType
+            });
+        });
+        const type = resultTypes[0];
+        return {
+            name: type.name,
+            type: type,
+            notNull: false,
+            table: type.table || ''
+        };
     }
     throw Error('traverse_expr not supported:' + expr.getText());
 }
-function inferNotNull_expr(expr, fromColumns) {
-    var _a;
-    const column_name = expr.column_name();
-    if (column_name) {
-        const fieldName = (0, select_columns_1.splitName)(column_name.getText());
-        const column = (0, select_columns_1.findColumn)(fieldName, fromColumns);
-        return column.notNull;
-    }
-    const function_name = (_a = expr.function_name()) === null || _a === void 0 ? void 0 : _a.getText().toLowerCase();
-    if (function_name == 'count') {
-        return true;
-    }
-    return false;
+function traverse_column_name(column_name, traverseContext) {
+    const fieldName = (0, select_columns_1.splitName)(column_name.getText());
+    const column = (0, select_columns_1.findColumn)(fieldName, traverseContext.fromColumns);
+    const typeVar = (0, collect_constraints_1.freshVar)(column.columnName, column.columnType.type, column.tableAlias || column.table);
+    return {
+        name: typeVar.name,
+        type: typeVar,
+        table: column.tableAlias || column.table,
+        notNull: column.notNull
+    };
 }
-function isMultipleRowResult(sql_stmtContext, fromColumns) {
-    const select_stmt = sql_stmtContext.select_stmt();
+function isMultipleRowResult(select_stmt, fromColumns) {
     if (select_stmt.select_core_list().length == 1) { //UNION queries are multipleRowsResult = true
         const select_core = select_stmt.select_core(0);
         const from = select_core.FROM_();
@@ -358,7 +579,9 @@ function isAgregateFunction(result_column) {
     const function_name = (_b = (_a = result_column.expr()) === null || _a === void 0 ? void 0 : _a.function_name()) === null || _b === void 0 ? void 0 : _b.getText().toLowerCase();
     return function_name == 'count'
         || function_name == 'sum'
-        || function_name == 'avg';
+        || function_name == 'avg'
+        || function_name == 'min'
+        || function_name == 'max';
 }
 function isLimitOne(select_stmt) {
     const limit_stmt = select_stmt.limit_stmt();
@@ -393,4 +616,83 @@ function is_single_result(expr, fromColumns) {
     }
     return false;
 }
+function traverse_insert_stmt(insert_stmt, traverseContext) {
+    const table_name = insert_stmt.table_name();
+    const fromColumns = (0, select_columns_1.filterColumns)(traverseContext.dbSchema, [], '', (0, select_columns_1.splitName)(table_name.getText()));
+    const columns = insert_stmt.column_name_list().map(column_name => {
+        return traverse_column_name(column_name, Object.assign(Object.assign({}, traverseContext), { fromColumns }));
+    });
+    const insertColumns = [];
+    const value_row_list = insert_stmt.values_clause().value_row_list();
+    value_row_list.forEach((value_row) => {
+        value_row.expr_list().forEach((expr, index) => {
+            const numberParamsBefore = traverseContext.parameters.length;
+            const exprType = traverse_expr(expr, traverseContext);
+            traverseContext.parameters.slice(numberParamsBefore).forEach((param) => {
+                const col = columns[index];
+                traverseContext.constraints.push({
+                    expression: expr.getText(),
+                    type1: col.type,
+                    type2: exprType.type
+                });
+                insertColumns.push(Object.assign(Object.assign({}, param), { notNull: exprType.name == '?' ? col.notNull : param.notNull }));
+            });
+        });
+    });
+    const queryResult = {
+        queryType: 'Insert',
+        columns: insertColumns
+    };
+    return queryResult;
+}
+function traverse_update_stmt(update_stmt, traverseContext) {
+    const table_name = update_stmt.qualified_table_name().getText();
+    const fromColumns = (0, select_columns_1.filterColumns)(traverseContext.dbSchema, [], '', (0, select_columns_1.splitName)(table_name));
+    const column_name_list = Array.from({ length: update_stmt.ASSIGN_list().length })
+        .map((_, i) => update_stmt.column_name(i));
+    const columns = column_name_list.map(column_name => {
+        return traverse_column_name(column_name, Object.assign(Object.assign({}, traverseContext), { fromColumns }));
+    });
+    const updateColumns = [];
+    const whereParams = [];
+    const expr_list = update_stmt.expr_list();
+    let paramsBefore = traverseContext.parameters.length;
+    expr_list.forEach((expr, index) => {
+        paramsBefore = traverseContext.parameters.length;
+        const exprType = traverse_expr(expr, Object.assign(Object.assign({}, traverseContext), { fromColumns }));
+        if (!update_stmt.WHERE_() || expr.start.start < update_stmt.WHERE_().symbol.start) {
+            const col = columns[index];
+            traverseContext.constraints.push({
+                expression: expr.getText(),
+                type1: col.type,
+                type2: exprType.type
+            });
+            traverseContext.parameters.slice(paramsBefore).forEach((param, index) => {
+                updateColumns.push(Object.assign(Object.assign({}, param), { notNull: param.notNull && col.notNull }));
+            });
+        }
+        else {
+            traverseContext.parameters.slice(paramsBefore).forEach((param, index) => {
+                whereParams.push(param);
+            });
+        }
+    });
+    const queryResult = {
+        queryType: 'Update',
+        columns: updateColumns,
+        params: whereParams
+    };
+    return queryResult;
+}
+function traverse_delete_stmt(delete_stmt, traverseContext) {
+    const table_name = delete_stmt.qualified_table_name().getText();
+    const fromColumns = (0, select_columns_1.filterColumns)(traverseContext.dbSchema, [], '', (0, select_columns_1.splitName)(table_name));
+    const expr = delete_stmt.expr();
+    traverse_expr(expr, Object.assign(Object.assign({}, traverseContext), { fromColumns }));
+    const queryResult = {
+        queryType: 'Delete',
+        params: traverseContext.parameters
+    };
+    return queryResult;
+}
 //# sourceMappingURL=traverse.js.map