typesql-cli 0.10.5 → 0.10.7

package/sqlite-query-analyzer/traverse.js

@@ -52,12 +52,14 @@ function traverse_select_stmt(select_stmt, traverseContext, subQuery = false, re
         common_table_expression.forEach((common_table_expression) => {
             const table_name = common_table_expression.table_name();
             const recursiveNames = common_table_expression.column_name_list().map((column_name) => column_name.getText());
+            const paramsBefore = traverseContext.parameters.length;
             const select_stmt = common_table_expression.select_stmt();
             traverse_select_stmt(select_stmt, Object.assign(Object.assign({}, traverseContext), { subQuery: true }), subQuery, recursive, recursiveNames, table_name.getText());
+            const parameters = traverseContext.parameters.slice(paramsBefore).map((_, index) => paramsBefore + index);
             traverseContext.dynamicSqlInfo2.with.push({
                 fragment: extractOriginalSql(common_table_expression),
                 relationName: table_name.getText(),
-                parameters: []
+                parameters: parameters
             });
         });
     }
@@ -404,807 +406,874 @@ function traverse_table_or_subquery(table_or_subquery_list, join_constraint_list
 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 === 'avg') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'REAL');
-        const sumParamExpr = expr.expr(0);
-        const paramType = traverse_expr(sumParamExpr, traverseContext);
-        if (paramType.type.kind === 'TypeVar') {
-            functionType.table = paramType.table;
-        }
+    if (function_name) {
+        return traverse_function(expr, function_name, traverseContext);
+    }
+    const column_name = expr.column_name();
+    const table_name = expr.table_name();
+    if (column_name) {
+        const type = traverse_column_name(column_name, table_name, traverseContext);
         return {
-            name: functionType.name,
-            type: functionType,
-            notNull: paramType.notNull,
-            table: functionType.table || ''
+            name: type.columnName,
+            type: type.columnType,
+            notNull: type.notNull,
+            table: type.tableAlias || type.table
         };
     }
-    if (function_name === 'sum') {
-        const sumParamExpr = expr.expr(0);
-        const paramType = traverse_expr(sumParamExpr, traverseContext);
+    const literal = expr.literal_value();
+    if (literal) {
+        if (literal.STRING_LITERAL()) {
+            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()) {
+            const type = (0, collect_constraints_1.freshVar)(literal.getText(), 'INTEGER');
+            return {
+                name: type.name,
+                type: type,
+                notNull: true,
+                table: type.table || ''
+            };
+        }
+        if (literal.TRUE_() || literal.FALSE_()) {
+            const type = (0, collect_constraints_1.freshVar)(literal.getText(), 'BOOLEAN');
+            return {
+                name: type.name,
+                type: type,
+                notNull: true,
+                table: type.table || ''
+            };
+        }
+        const type = (0, collect_constraints_1.freshVar)(literal.getText(), '?');
         return {
-            name: expr.getText(),
-            type: paramType.type,
-            notNull: false,
-            table: paramType.table || ''
+            name: type.name,
+            type: type,
+            notNull: literal.NULL_() == null,
+            table: type.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);
+    if (expr.unary_operator()) {
+        const exprRight = expr.expr(0);
+        return traverse_expr(exprRight, traverseContext);
+    }
+    const parameter = expr.BIND_PARAMETER();
+    if (parameter) {
+        const param = (0, collect_constraints_1.freshVar)('?', '?');
+        const type = {
+            name: param.name,
+            type: param,
+            notNull: undefined,
+            table: param.table || '',
+            paramIndex: parameter.symbol.start
+        };
+        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);
+        const typeRight = traverse_expr(exprRight, traverseContext);
+        const returnType = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: functionType,
-            type2: paramType.type
+            type1: typeLeft.type,
+            type2: returnType
+        });
+        traverseContext.constraints.push({
+            expression: expr.getText(),
+            type1: typeRight.type,
+            type2: returnType
         });
         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.type.kind === 'TypeVar') {
-                functionType.table = paramType.table;
-            }
-        }
-        return {
-            name: functionType.name,
-            type: functionType,
-            notNull: true,
-            table: functionType.table || ''
+            name: returnType.name,
+            type: returnType,
+            notNull: typeLeft.notNull && typeRight.notNull,
+            table: returnType.table || ''
         };
     }
-    if (function_name === 'concat') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT');
-        expr.expr_list().forEach((paramExpr) => {
-            const paramType = traverse_expr(paramExpr, traverseContext);
+    if (expr.PLUS() || expr.MINUS()) {
+        const returnType = (0, collect_constraints_1.freshVar)(expr.getText(), 'REAL'); //NUMERIC
+        const exprLeft = expr.expr(0);
+        const exprRight = expr.expr(1);
+        const typeLeft = traverse_expr(exprLeft, traverseContext);
+        const typeRight = traverse_expr(exprRight, traverseContext);
+        typeLeft.table = '';
+        typeRight.table = '';
+        traverseContext.constraints.push({
+            expression: exprLeft.getText(),
+            type1: returnType,
+            type2: typeLeft.type
+        });
+        const isDateFunctionContext = expr.parentCtx instanceof sqlite_1.ExprContext && ((_b = expr.parentCtx.function_name()) === null || _b === void 0 ? void 0 : _b.getText().toLowerCase()) === 'date';
+        if (!isDateFunctionContext) {
             traverseContext.constraints.push({
-                expression: expr.getText(),
-                type1: functionType,
-                type2: paramType.type
+                expression: exprRight.getText(),
+                type1: returnType,
+                type2: typeRight.type
             });
-            if (paramType.type.kind === 'TypeVar') {
-                functionType.table = paramType.table;
-            }
+        }
+        return Object.assign(Object.assign({}, typeLeft), { notNull: typeLeft.notNull && typeRight.notNull });
+    }
+    if (expr.LT2() ||
+        expr.GT2() ||
+        expr.AMP() ||
+        expr.PIPE() ||
+        expr.LT() ||
+        expr.LT_EQ() ||
+        expr.GT() ||
+        expr.GT_EQ() ||
+        expr.NOT_EQ1() ||
+        expr.NOT_EQ2()) {
+        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.type,
+            type2: typeRight.type
         });
+        const resultType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
         return {
-            name: functionType.name,
-            type: functionType,
+            name: resultType.name,
+            type: resultType,
             notNull: true,
-            table: functionType.table || ''
+            table: resultType.table || ''
         };
     }
-    if (function_name === 'length') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
-        const paramExpr = expr.expr(0);
-        const paramType = traverse_expr(paramExpr, traverseContext);
+    if (expr.IS_()) {
+        //is null/is not null/is true, is false
+        const exprLeft = expr.expr(0);
+        const typeLeft = traverse_expr(exprLeft, traverseContext);
+        const exprRight = expr.expr(1);
+        const typeRight = traverse_expr(exprRight, traverseContext);
+        typeLeft.notNull = typeRight.notNull;
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: (0, collect_constraints_1.freshVar)(expr.getText(), '?'), //str or blob
-            type2: paramType.type
+            type1: typeLeft.type,
+            type2: typeRight.type
         });
-        if (paramType.type.kind === 'TypeVar') {
-            functionType.table = paramType.table;
-        }
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
         return {
-            name: functionType.name,
-            type: functionType,
-            notNull: false,
-            table: functionType.table || ''
+            name: type.name,
+            type: type,
+            notNull: true,
+            table: type.table || ''
         };
     }
-    if (function_name === 'group_concat') {
-        expr.expr_list().forEach((paramExpr) => {
-            const param1Type = traverse_expr(paramExpr, traverseContext);
-            traverseContext.constraints.push({
-                expression: expr.getText(),
-                type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT'),
-                type2: param1Type.type
-            });
+    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.type,
+            type2: typeRight.type
         });
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
         return {
-            name: expr.getText(),
-            type: (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT'),
-            notNull: false,
-            table: ''
-        };
-    }
-    if (function_name === 'random') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
-        return {
-            name: functionType.name,
-            type: functionType,
+            name: type.name,
+            type: type,
             notNull: true,
-            table: ''
+            table: type.table || ''
         };
     }
-    if (function_name === 'round') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'REAL');
-        const param1Expr = expr.expr(0);
-        const param1Type = traverse_expr(param1Expr, traverseContext);
-        traverseContext.constraints.push({
-            expression: expr.getText(),
-            type1: functionType,
-            type2: param1Type.type
-        });
-        const param2Expr = expr.expr(1);
-        if (param2Expr) {
-            const param2Type = traverse_expr(param2Expr, traverseContext);
-            traverseContext.constraints.push({
-                expression: expr.getText(),
-                type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER'),
-                type2: param2Type.type
-            });
+    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;
         }
-        return {
-            name: functionType.name,
-            type: functionType,
-            notNull: param1Type.notNull,
-            table: param1Type.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
+            expression: expr.getText(),
+            type1: exprType.type,
+            type2: between1.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(), 'DATE');
-        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 === 'julianday') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'REAL');
-        const paramExpr = expr.expr(0);
-        const notNull = paramExpr.getText().toLowerCase() === `'now'`;
-        const paramType = traverse_expr(paramExpr, traverseContext);
-        traverseContext.constraints.push({
-            expression: paramExpr.getText(),
-            type1: (0, collect_constraints_1.freshVar)(paramExpr.getText(), 'DATE'),
-            type2: paramType.type
+            expression: expr.getText(),
+            type1: exprType.type,
+            type2: between2.type
         });
-        return {
-            name: functionType.name,
-            type: functionType,
-            notNull,
-            table: functionType.table || ''
-        };
-    }
-    if (function_name === 'unixepoch') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
-        const paramExpr = expr.expr(0);
-        const notNull = paramExpr.getText().toLowerCase() === `'now'`;
-        const paramType = traverse_expr(paramExpr, traverseContext);
         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,
-            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;
+            expression: expr.getText(),
+            type1: between1.type,
+            type2: between2.type
         });
-        return {
-            name: functionType.name,
-            type: functionType,
-            notNull: paramTypes.every((param) => param.notNull),
-            table: functionType.table || ''
-        };
-    }
-    if (function_name === 'row_number' || function_name === 'rank' || function_name === 'dense_rank') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
-        return {
-            name: functionType.name,
-            type: functionType,
-            notNull: true,
-            table: functionType.table || ''
-        };
-    }
-    if (function_name === 'first_value' || function_name === 'last_value') {
-        const paramExpr = expr.expr(0);
-        const paramType = traverse_expr(paramExpr, traverseContext);
-        return paramType;
-    }
-    if (function_name === 'lead' || function_name === 'lag') {
-        const paramExpr = expr.expr(0);
-        const paramType = traverse_expr(paramExpr, traverseContext);
-        return Object.assign(Object.assign({}, paramType), { notNull: false });
+        return exprType;
     }
-    if (function_name === 'iif') {
+    if (expr.OR_() || expr.AND_()) {
         const expr1 = expr.expr(0);
-        traverse_expr(expr1, traverseContext);
         const expr2 = expr.expr(1);
-        const expr2Type = traverse_expr(expr2, traverseContext);
-        const expr3 = expr.expr(2);
-        const expr3Type = traverse_expr(expr3, traverseContext);
-        traverseContext.constraints.push({
-            expression: expr.getText(),
-            type1: expr2Type.type,
-            type2: expr3Type.type
-        });
-        return Object.assign(Object.assign({}, expr2Type), { notNull: expr2Type.notNull && expr3Type.notNull });
-    }
-    if (function_name === 'vector') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'BLOB');
-        const param1Expr = expr.expr(0);
-        const param1Type = traverse_expr(param1Expr, traverseContext);
-        param1Type.notNull = true;
-        traverseContext.constraints.push({
-            expression: expr.getText(),
-            type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT'),
-            type2: param1Type.type
-        });
-        return {
-            name: expr.getText(),
-            type: functionType,
-            notNull: true,
-            table: ''
-        };
+        traverse_expr(expr1, traverseContext);
+        return traverse_expr(expr2, traverseContext);
     }
-    if (function_name === 'highlight' || function_name === 'snippet') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT');
-        const param0Expr = expr.expr(0);
-        const param1Expr = expr.expr(1);
-        const param1Type = traverse_expr(param1Expr, traverseContext);
-        param1Type.notNull = true;
-        traverseContext.constraints.push({
-            expression: param1Expr.getText(),
-            type1: (0, collect_constraints_1.freshVar)(param1Expr.getText(), 'INTEGER'),
-            type2: param1Type.type
-        });
-        const param2Expr = expr.expr(2);
-        const param2Type = traverse_expr(param2Expr, traverseContext);
-        param2Type.notNull = true;
-        traverseContext.constraints.push({
-            expression: param2Expr.getText(),
-            type1: (0, collect_constraints_1.freshVar)(param2Expr.getText(), 'TEXT'),
-            type2: param2Type.type
-        });
-        const param3Expr = expr.expr(3);
-        const param3Type = traverse_expr(param3Expr, traverseContext);
-        param3Type.notNull = true;
-        traverseContext.constraints.push({
-            expression: param3Expr.getText(),
-            type1: (0, collect_constraints_1.freshVar)(param3Expr.getText(), 'TEXT'),
-            type2: param3Type.type
-        });
-        if (function_name === 'snippet') {
-            const param4Expr = expr.expr(4);
-            const param4Type = traverse_expr(param4Expr, traverseContext);
-            param4Type.notNull = true;
-            traverseContext.constraints.push({
-                expression: param4Expr.getText(),
-                type1: (0, collect_constraints_1.freshVar)(param4Expr.getText(), 'TEXT'),
-                type2: param4Type.type
+    if (expr.IN_()) {
+        const exprList = expr.expr_list();
+        const inExprLeft = exprList[0];
+        const typeLeft = traverse_expr(inExprLeft, traverseContext);
+        if (typeLeft.name === '?') {
+            typeLeft.notNull = true;
+        }
+        if (expr.NOT_()) {
+            //NOT IN (SELECT...)
+            const select_stmt = expr.select_stmt();
+            if (select_stmt) {
+                const select_stmt_type = traverse_select_stmt(select_stmt, traverseContext, true);
+                const selectType = select_stmt_type.columns[0];
+                traverseContext.constraints.push({
+                    expression: expr.getText(),
+                    type1: typeLeft.type,
+                    type2: Object.assign(Object.assign({}, selectType.type), { list: true })
+                });
+            }
+            //NOT IN (1, 2, 3)
+            exprList.slice(1).forEach((inExpr) => {
+                const typeRight = traverse_expr(inExpr, traverseContext);
+                if (typeRight.name === '?') {
+                    typeRight.notNull = true;
+                }
+                traverseContext.constraints.push({
+                    expression: expr.getText(),
+                    type1: typeLeft.type,
+                    type2: Object.assign(Object.assign({}, typeRight.type), { list: true })
+                });
             });
-            const param5Expr = expr.expr(5);
-            const param5Type = traverse_expr(param5Expr, traverseContext);
-            param5Type.notNull = true;
-            traverseContext.constraints.push({
-                expression: param5Expr.getText(),
-                type1: (0, collect_constraints_1.freshVar)(param5Expr.getText(), 'INTEGER'),
-                type2: param5Type.type
+        }
+        else {
+            const rightExpr = exprList[1];
+            //IN (SELECT...)
+            const select_stmt2 = rightExpr.select_stmt();
+            if (select_stmt2) {
+                const select_stmt_type = traverse_select_stmt(select_stmt2, traverseContext, true);
+                const selectType2 = select_stmt_type.columns[0];
+                traverseContext.constraints.push({
+                    expression: expr.getText(),
+                    type1: typeLeft.type,
+                    type2: Object.assign(Object.assign({}, selectType2.type), { list: true })
+                });
+            }
+            //IN (1, 2, 3)
+            rightExpr.expr_list().forEach((inExpr2) => {
+                const typeRight = traverse_expr(inExpr2, traverseContext);
+                if (typeRight.name === '?') {
+                    typeRight.notNull = true;
+                }
+                traverseContext.constraints.push({
+                    expression: expr.getText(),
+                    type1: typeLeft.type,
+                    type2: Object.assign(Object.assign({}, typeRight.type), { list: true })
+                });
             });
         }
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
         return {
-            name: expr.getText(),
-            type: functionType,
-            notNull: false,
-            table: param0Expr.getText()
+            name: type.name,
+            type: type,
+            notNull: true,
+            table: type.table || ''
         };
     }
-    if (function_name === 'vector_extract') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT');
-        const param1Expr = expr.expr(0);
-        const param1Type = traverse_expr(param1Expr, traverseContext);
+    if (expr.LIKE_() || expr.GLOB_()) {
+        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: (0, collect_constraints_1.freshVar)(expr.getText(), 'BLOB'),
-            type2: param1Type.type
+            type1: typeLeft.type,
+            type2: typeRight.type
+        });
+        traverseContext.constraints.push({
+            expression: expr.getText(),
+            type1: typeLeft.type,
+            type2: (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT')
         });
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
         return {
-            name: expr.getText(),
-            type: functionType,
+            name: type.name,
+            type: type,
             notNull: true,
-            table: ''
+            table: type.table || ''
         };
     }
-    if (function_name === 'vector_distance_cos') {
-        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'REAL');
-        const param1Expr = expr.expr(0);
-        if (param1Expr) {
-            const param1Type = traverse_expr(param1Expr, traverseContext);
-            param1Type.notNull = true;
-            traverseContext.constraints.push({
-                expression: expr.getText(),
-                type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'BLOB'),
-                type2: param1Type.type
-            });
-        }
-        const param2Expr = expr.expr(1);
-        if (param2Expr) {
-            const param2Type = traverse_expr(param2Expr, traverseContext);
-            param2Type.notNull = true;
-            traverseContext.constraints.push({
-                expression: expr.getText(),
-                type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT'),
-                type2: param2Type.type
-            });
+    if (expr.MATCH_()) {
+        const exprLeft = expr.expr(0);
+        const exprRight = expr.expr(1);
+        const typeRight = traverse_expr(exprRight, traverseContext);
+        if (typeRight.name === '?') {
+            typeRight.notNull = true;
+            typeRight.type = (0, collect_constraints_1.freshVar)(exprRight.getText(), 'TEXT');
         }
+        const type = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
         return {
-            name: expr.getText(),
-            type: functionType,
+            name: type.name,
+            type: type,
             notNull: true,
-            table: ''
+            table: type.table || ''
         };
     }
-    if (function_name) {
-        throw Error(`traverse_expr: function not supported:${function_name}`);
-    }
-    const column_name = expr.column_name();
-    const table_name = expr.table_name();
-    if (column_name) {
-        const type = traverse_column_name(column_name, table_name, traverseContext);
+    const select_stmt = expr.select_stmt();
+    if (select_stmt) {
+        const subQueryType = traverse_select_stmt(select_stmt, Object.assign(Object.assign({}, traverseContext), { subQuery: true }), true);
+        const type = Object.assign(Object.assign({}, subQueryType.columns[0].type), { table: '' });
         return {
-            name: type.columnName,
-            type: type.columnType,
-            notNull: type.notNull,
-            table: type.tableAlias || type.table
+            name: type.name,
+            type: type,
+            notNull: subQueryType.columns[0].notNull,
+            table: type.table || ''
         };
     }
-    const literal = expr.literal_value();
-    if (literal) {
-        if (literal.STRING_LITERAL()) {
-            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()) {
-            const type = (0, collect_constraints_1.freshVar)(literal.getText(), 'INTEGER');
-            return {
-                name: type.name,
-                type: type,
-                notNull: true,
-                table: type.table || ''
-            };
-        }
-        if (literal.TRUE_() || literal.FALSE_()) {
-            const type = (0, collect_constraints_1.freshVar)(literal.getText(), 'BOOLEAN');
-            return {
-                name: type.name,
-                type: type,
-                notNull: true,
-                table: type.table || ''
-            };
-        }
-        const type = (0, collect_constraints_1.freshVar)(literal.getText(), '?');
+    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: literal.NULL_() == null,
+            notNull: exprTypes.every((type) => type.notNull),
             table: type.table || ''
         };
     }
-    if (expr.unary_operator()) {
-        const exprRight = expr.expr(0);
-        return traverse_expr(exprRight, traverseContext);
+    if (expr.CASE_()) {
+        const resultTypes = []; //then and else
+        const whenTypes = [];
+        expr.expr_list().forEach((expr_, index) => {
+            const type = traverse_expr(expr_, traverseContext);
+            if (index % 2 === 0 && (!expr.ELSE_() || index < expr.expr_list().length - 1)) {
+                whenTypes.push(type);
+            }
+            else {
+                resultTypes.push(type);
+            }
+        });
+        resultTypes.forEach((resultType, index) => {
+            if (index > 0) {
+                traverseContext.constraints.push({
+                    expression: expr.getText(),
+                    type1: resultTypes[0].type,
+                    type2: resultType.type
+                });
+            }
+        });
+        whenTypes.forEach((whenType) => {
+            traverseContext.constraints.push({
+                expression: expr.getText(),
+                type1: (0, collect_constraints_1.freshVar)('INTEGER', 'INTEGER'),
+                type2: whenType.type
+            });
+        });
+        const type = resultTypes[0];
+        return {
+            name: extractOriginalSql(expr),
+            type: type.type,
+            notNull: expr.ELSE_() ? resultTypes.every((type) => type.notNull) : false,
+            table: type.table || ''
+        };
     }
-    const parameter = expr.BIND_PARAMETER();
-    if (parameter) {
-        const param = (0, collect_constraints_1.freshVar)('?', '?');
-        const type = {
-            name: param.name,
-            type: param,
-            notNull: undefined,
-            table: param.table || '',
-            paramIndex: parameter.symbol.start
+    throw Error(`traverse_expr not supported:${expr.getText()}`);
+}
+function traverse_function(expr, function_name, traverseContext) {
+    if (function_name === 'avg') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'REAL');
+        const sumParamExpr = expr.expr(0);
+        const paramType = traverse_expr(sumParamExpr, traverseContext);
+        if (paramType.type.kind === 'TypeVar') {
+            functionType.table = paramType.table;
+        }
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: paramType.notNull,
+            table: functionType.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);
-        const typeRight = traverse_expr(exprRight, traverseContext);
-        const returnType = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
-        traverseContext.constraints.push({
-            expression: expr.getText(),
-            type1: typeLeft.type,
-            type2: returnType
-        });
-        traverseContext.constraints.push({
-            expression: expr.getText(),
-            type1: typeRight.type,
-            type2: returnType
-        });
+    if (function_name === 'sum') {
+        const sumParamExpr = expr.expr(0);
+        const paramType = traverse_expr(sumParamExpr, traverseContext);
         return {
-            name: returnType.name,
-            type: returnType,
-            notNull: typeLeft.notNull && typeRight.notNull,
-            table: returnType.table || ''
+            name: expr.getText(),
+            type: paramType.type,
+            notNull: false,
+            table: paramType.table || ''
         };
     }
-    if (expr.PLUS() || expr.MINUS()) {
-        const returnType = (0, collect_constraints_1.freshVar)(expr.getText(), 'REAL'); //NUMERIC
-        const exprLeft = expr.expr(0);
-        const exprRight = expr.expr(1);
-        const typeLeft = traverse_expr(exprLeft, traverseContext);
-        const typeRight = traverse_expr(exprRight, traverseContext);
-        typeLeft.table = '';
-        typeRight.table = '';
-        traverseContext.constraints.push({
-            expression: exprLeft.getText(),
-            type1: returnType,
-            type2: typeLeft.type
+    if (function_name === 'min' || function_name === 'max') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+        let paramNotNull = false;
+        expr.expr_list().forEach((exprParam, index, array) => {
+            const paramType = traverse_expr(exprParam, traverseContext);
+            if (array.length == 1 && index == 0) {
+                paramNotNull = paramType.notNull;
+            }
+            traverseContext.constraints.push({
+                expression: expr.getText(),
+                type1: functionType,
+                type2: paramType.type
+            });
         });
-        const isDateFunctionContext = expr.parentCtx instanceof sqlite_1.ExprContext && ((_b = expr.parentCtx.function_name()) === null || _b === void 0 ? void 0 : _b.getText().toLowerCase()) === 'date';
-        if (!isDateFunctionContext) {
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: paramNotNull,
+            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.type.kind === 'TypeVar') {
+                functionType.table = paramType.table;
+            }
+        }
+        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');
+        expr.expr_list().forEach((paramExpr) => {
+            const paramType = traverse_expr(paramExpr, traverseContext);
             traverseContext.constraints.push({
-                expression: exprRight.getText(),
-                type1: returnType,
-                type2: typeRight.type
+                expression: expr.getText(),
+                type1: functionType,
+                type2: paramType.type
             });
-        }
-        return Object.assign(Object.assign({}, typeLeft), { notNull: typeLeft.notNull && typeRight.notNull });
-    }
-    if (expr.LT2() ||
-        expr.GT2() ||
-        expr.AMP() ||
-        expr.PIPE() ||
-        expr.LT() ||
-        expr.LT_EQ() ||
-        expr.GT() ||
-        expr.GT_EQ() ||
-        expr.NOT_EQ1() ||
-        expr.NOT_EQ2()) {
-        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.type,
-            type2: typeRight.type
+            if (paramType.type.kind === 'TypeVar') {
+                functionType.table = paramType.table;
+            }
         });
-        const resultType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
         return {
-            name: resultType.name,
-            type: resultType,
+            name: functionType.name,
+            type: functionType,
             notNull: true,
-            table: resultType.table || ''
+            table: functionType.table || ''
         };
     }
-    if (expr.IS_()) {
-        //is null/is not null/is true, is false
-        const exprLeft = expr.expr(0);
-        const typeLeft = traverse_expr(exprLeft, traverseContext);
-        const exprRight = expr.expr(1);
-        const typeRight = traverse_expr(exprRight, traverseContext);
-        typeLeft.notNull = typeRight.notNull;
+    if (function_name === 'length') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
+        const paramExpr = expr.expr(0);
+        const paramType = traverse_expr(paramExpr, traverseContext);
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: typeLeft.type,
-            type2: typeRight.type
+            type1: (0, collect_constraints_1.freshVar)(expr.getText(), '?'), //str or blob
+            type2: paramType.type
         });
-        const type = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
+        if (paramType.type.kind === 'TypeVar') {
+            functionType.table = paramType.table;
+        }
         return {
-            name: type.name,
-            type: type,
-            notNull: true,
-            table: type.table || ''
+            name: functionType.name,
+            type: functionType,
+            notNull: false,
+            table: functionType.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.type,
-            type2: typeRight.type
+    if (function_name === 'group_concat') {
+        expr.expr_list().forEach((paramExpr) => {
+            const param1Type = traverse_expr(paramExpr, traverseContext);
+            traverseContext.constraints.push({
+                expression: expr.getText(),
+                type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT'),
+                type2: param1Type.type
+            });
         });
-        const type = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
         return {
-            name: type.name,
-            type: type,
+            name: expr.getText(),
+            type: (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT'),
+            notNull: false,
+            table: ''
+        };
+    }
+    if (function_name === 'random') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
+        return {
+            name: functionType.name,
+            type: functionType,
             notNull: true,
-            table: type.table || ''
+            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;
-        }
+    if (function_name === 'round') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'REAL');
+        const param1Expr = expr.expr(0);
+        const param1Type = traverse_expr(param1Expr, traverseContext);
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: exprType.type,
-            type2: between1.type
+            type1: functionType,
+            type2: param1Type.type
         });
-        traverseContext.constraints.push({
-            expression: expr.getText(),
-            type1: exprType.type,
-            type2: between2.type
+        const param2Expr = expr.expr(1);
+        if (param2Expr) {
+            const param2Type = traverse_expr(param2Expr, traverseContext);
+            traverseContext.constraints.push({
+                expression: expr.getText(),
+                type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER'),
+                type2: param2Type.type
+            });
+        }
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: param1Type.notNull,
+            table: param1Type.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: expr.getText(),
-            type1: between1.type,
-            type2: between2.type
+            expression: paramExpr.getText(),
+            type1: (0, collect_constraints_1.freshVar)(paramExpr.getText(), 'DATE_TIME'),
+            type2: paramType.type
         });
-        return exprType;
-    }
-    if (expr.OR_() || expr.AND_()) {
-        const expr1 = expr.expr(0);
-        const expr2 = expr.expr(1);
-        traverse_expr(expr1, traverseContext);
-        return traverse_expr(expr2, traverseContext);
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: false,
+            table: functionType.table || ''
+        };
     }
-    if (expr.IN_()) {
-        const exprList = expr.expr_list();
-        const inExprLeft = exprList[0];
-        const typeLeft = traverse_expr(inExprLeft, traverseContext);
-        if (typeLeft.name === '?') {
-            typeLeft.notNull = true;
-        }
-        if (expr.NOT_()) {
-            //NOT IN (SELECT...)
-            const select_stmt = expr.select_stmt();
-            if (select_stmt) {
-                const select_stmt_type = traverse_select_stmt(select_stmt, traverseContext, true);
-                const selectType = select_stmt_type.columns[0];
+    if (function_name === 'date' || function_name === 'time' || function_name === 'datetime') {
+        const dateType = function_name === 'date' ? 'DATE' : 'DATE_TIME';
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), dateType);
+        const param1 = traverse_expr(expr.expr(0), traverseContext);
+        param1.notNull = true;
+        expr.expr_list().forEach((paramExpr, index, arr) => {
+            if (index === 0 && arr.length === 1) {
                 traverseContext.constraints.push({
-                    expression: expr.getText(),
-                    type1: typeLeft.type,
-                    type2: Object.assign(Object.assign({}, selectType.type), { list: true })
+                    expression: paramExpr.getText(),
+                    type1: (0, collect_constraints_1.freshVar)(paramExpr.getText(), dateType),
+                    type2: param1.type
                 });
             }
-            //NOT IN (1, 2, 3)
-            exprList.slice(1).forEach((inExpr) => {
-                const typeRight = traverse_expr(inExpr, traverseContext);
-                if (typeRight.name === '?') {
-                    typeRight.notNull = true;
+            else if (index > 0) {
+                const paramType = traverse_expr(paramExpr, traverseContext);
+                if (index === 1) {
+                    if (paramType.name === "'auto'" || paramType.name === "'unixepoch'") {
+                        traverseContext.constraints.push({
+                            expression: paramExpr.getText(),
+                            type1: (0, collect_constraints_1.freshVar)(paramExpr.getText(), 'NUMERIC'),
+                            type2: param1.type
+                        });
+                    }
                 }
                 traverseContext.constraints.push({
-                    expression: expr.getText(),
-                    type1: typeLeft.type,
-                    type2: Object.assign(Object.assign({}, typeRight.type), { list: true })
-                });
-            });
-        }
-        else {
-            const rightExpr = exprList[1];
-            //IN (SELECT...)
-            const select_stmt2 = rightExpr.select_stmt();
-            if (select_stmt2) {
-                const select_stmt_type = traverse_select_stmt(select_stmt2, traverseContext, true);
-                const selectType2 = select_stmt_type.columns[0];
-                traverseContext.constraints.push({
-                    expression: expr.getText(),
-                    type1: typeLeft.type,
-                    type2: Object.assign(Object.assign({}, selectType2.type), { list: true })
+                    expression: paramExpr.getText(),
+                    type1: (0, collect_constraints_1.freshVar)(paramExpr.getText(), 'TEXT'),
+                    type2: paramType.type
                 });
             }
-            //IN (1, 2, 3)
-            rightExpr.expr_list().forEach((inExpr2) => {
-                const typeRight = traverse_expr(inExpr2, traverseContext);
-                if (typeRight.name === '?') {
-                    typeRight.notNull = true;
-                }
-                traverseContext.constraints.push({
-                    expression: expr.getText(),
-                    type1: typeLeft.type,
-                    type2: Object.assign(Object.assign({}, typeRight.type), { list: true })
-                });
+        });
+        return {
+            name: functionType.name,
+            type: functionType,
+            notNull: false,
+            table: functionType.table || ''
+        };
+    }
+    if (function_name === 'julianday') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'REAL');
+        const paramExpr = expr.expr(0);
+        const notNull = paramExpr.getText().toLowerCase() === `'now'`;
+        const paramType = traverse_expr(paramExpr, traverseContext);
+        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,
+            table: functionType.table || ''
+        };
+    }
+    if (function_name === 'unixepoch') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
+        const paramExpr = expr.expr(0);
+        const notNull = paramExpr.getText().toLowerCase() === `'now'`;
+        const paramType = traverse_expr(paramExpr, traverseContext);
+        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,
+            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
             });
-        }
-        const type = (0, collect_constraints_1.freshVar)(expr.getText(), '?');
+            return paramType;
+        });
         return {
-            name: type.name,
-            type: type,
+            name: functionType.name,
+            type: functionType,
+            notNull: paramTypes.every((param) => param.notNull),
+            table: functionType.table || ''
+        };
+    }
+    if (function_name === 'row_number' || function_name === 'rank' || function_name === 'dense_rank') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
+        return {
+            name: functionType.name,
+            type: functionType,
             notNull: true,
-            table: type.table || ''
+            table: functionType.table || ''
         };
     }
-    if (expr.LIKE_() || expr.GLOB_()) {
-        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;
-        }
+    if (function_name === 'first_value' || function_name === 'last_value') {
+        const paramExpr = expr.expr(0);
+        const paramType = traverse_expr(paramExpr, traverseContext);
+        return paramType;
+    }
+    if (function_name === 'lead' || function_name === 'lag') {
+        const paramExpr = expr.expr(0);
+        const paramType = traverse_expr(paramExpr, traverseContext);
+        return Object.assign(Object.assign({}, paramType), { notNull: false });
+    }
+    if (function_name === 'iif') {
+        const expr1 = expr.expr(0);
+        traverse_expr(expr1, traverseContext);
+        const expr2 = expr.expr(1);
+        const expr2Type = traverse_expr(expr2, traverseContext);
+        const expr3 = expr.expr(2);
+        const expr3Type = traverse_expr(expr3, traverseContext);
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: typeLeft.type,
-            type2: typeRight.type
+            type1: expr2Type.type,
+            type2: expr3Type.type
         });
+        return Object.assign(Object.assign({}, expr2Type), { notNull: expr2Type.notNull && expr3Type.notNull });
+    }
+    if (function_name === 'vector') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'BLOB');
+        const param1Expr = expr.expr(0);
+        const param1Type = traverse_expr(param1Expr, traverseContext);
+        param1Type.notNull = true;
         traverseContext.constraints.push({
             expression: expr.getText(),
-            type1: typeLeft.type,
-            type2: (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT')
+            type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT'),
+            type2: param1Type.type
         });
-        const type = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
         return {
-            name: type.name,
-            type: type,
+            name: expr.getText(),
+            type: functionType,
             notNull: true,
-            table: type.table || ''
+            table: ''
         };
     }
-    if (expr.MATCH_()) {
-        const exprLeft = expr.expr(0);
-        const exprRight = expr.expr(1);
-        const typeRight = traverse_expr(exprRight, traverseContext);
-        if (typeRight.name === '?') {
-            typeRight.notNull = true;
-            typeRight.type = (0, collect_constraints_1.freshVar)(exprRight.getText(), 'TEXT');
+    if (function_name === 'highlight' || function_name === 'snippet') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT');
+        const param0Expr = expr.expr(0);
+        const param1Expr = expr.expr(1);
+        const param1Type = traverse_expr(param1Expr, traverseContext);
+        param1Type.notNull = true;
+        traverseContext.constraints.push({
+            expression: param1Expr.getText(),
+            type1: (0, collect_constraints_1.freshVar)(param1Expr.getText(), 'INTEGER'),
+            type2: param1Type.type
+        });
+        const param2Expr = expr.expr(2);
+        const param2Type = traverse_expr(param2Expr, traverseContext);
+        param2Type.notNull = true;
+        traverseContext.constraints.push({
+            expression: param2Expr.getText(),
+            type1: (0, collect_constraints_1.freshVar)(param2Expr.getText(), 'TEXT'),
+            type2: param2Type.type
+        });
+        const param3Expr = expr.expr(3);
+        const param3Type = traverse_expr(param3Expr, traverseContext);
+        param3Type.notNull = true;
+        traverseContext.constraints.push({
+            expression: param3Expr.getText(),
+            type1: (0, collect_constraints_1.freshVar)(param3Expr.getText(), 'TEXT'),
+            type2: param3Type.type
+        });
+        if (function_name === 'snippet') {
+            const param4Expr = expr.expr(4);
+            const param4Type = traverse_expr(param4Expr, traverseContext);
+            param4Type.notNull = true;
+            traverseContext.constraints.push({
+                expression: param4Expr.getText(),
+                type1: (0, collect_constraints_1.freshVar)(param4Expr.getText(), 'TEXT'),
+                type2: param4Type.type
+            });
+            const param5Expr = expr.expr(5);
+            const param5Type = traverse_expr(param5Expr, traverseContext);
+            param5Type.notNull = true;
+            traverseContext.constraints.push({
+                expression: param5Expr.getText(),
+                type1: (0, collect_constraints_1.freshVar)(param5Expr.getText(), 'INTEGER'),
+                type2: param5Type.type
+            });
         }
-        const type = (0, collect_constraints_1.freshVar)(expr.getText(), 'INTEGER');
         return {
-            name: type.name,
-            type: type,
-            notNull: true,
-            table: type.table || ''
+            name: expr.getText(),
+            type: functionType,
+            notNull: false,
+            table: param0Expr.getText()
         };
     }
-    const select_stmt = expr.select_stmt();
-    if (select_stmt) {
-        const subQueryType = traverse_select_stmt(select_stmt, Object.assign(Object.assign({}, traverseContext), { subQuery: true }), true);
-        const type = Object.assign(Object.assign({}, subQueryType.columns[0].type), { table: '' });
+    if (function_name === 'vector_extract') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT');
+        const param1Expr = expr.expr(0);
+        const param1Type = traverse_expr(param1Expr, traverseContext);
+        traverseContext.constraints.push({
+            expression: expr.getText(),
+            type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'BLOB'),
+            type2: param1Type.type
+        });
         return {
-            name: type.name,
-            type: type,
-            notNull: subQueryType.columns[0].notNull,
-            table: type.table || ''
+            name: expr.getText(),
+            type: functionType,
+            notNull: true,
+            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);
+    if (function_name === 'vector_distance_cos') {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), 'REAL');
+        const param1Expr = expr.expr(0);
+        if (param1Expr) {
+            const param1Type = traverse_expr(param1Expr, traverseContext);
+            param1Type.notNull = true;
             traverseContext.constraints.push({
-                expression: innerExpr.getText(),
-                type1: exprType.type,
-                type2: type
+                expression: expr.getText(),
+                type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'BLOB'),
+                type2: param1Type.type
             });
-            return exprType;
-        });
+        }
+        const param2Expr = expr.expr(1);
+        if (param2Expr) {
+            const param2Type = traverse_expr(param2Expr, traverseContext);
+            param2Type.notNull = true;
+            traverseContext.constraints.push({
+                expression: expr.getText(),
+                type1: (0, collect_constraints_1.freshVar)(expr.getText(), 'TEXT'),
+                type2: param2Type.type
+            });
+        }
         return {
-            name: type.name,
-            type: type,
-            notNull: exprTypes.every((type) => type.notNull),
-            table: type.table || ''
+            name: expr.getText(),
+            type: functionType,
+            notNull: true,
+            table: ''
         };
     }
-    if (expr.CASE_()) {
-        const resultTypes = []; //then and else
-        const whenTypes = [];
-        expr.expr_list().forEach((expr_, index) => {
-            const type = traverse_expr(expr_, traverseContext);
-            if (index % 2 === 0 && (!expr.ELSE_() || index < expr.expr_list().length - 1)) {
-                whenTypes.push(type);
+    const sqlean_uuid_functions = {
+        'uuid4': {
+            paramsTypes: [],
+            returnType: {
+                type: 'TEXT',
+                notNull: true
             }
-            else {
-                resultTypes.push(type);
+        },
+        'uuid7': {
+            paramsTypes: [],
+            returnType: {
+                type: 'TEXT',
+                notNull: true
             }
-        });
-        resultTypes.forEach((resultType, index) => {
-            if (index > 0) {
+        }
+    };
+    const functionCatalog = sqlean_uuid_functions[function_name];
+    if (functionCatalog) {
+        const functionType = (0, collect_constraints_1.freshVar)(expr.getText(), functionCatalog.returnType.type);
+        expr.expr_list().forEach((exprParam, index) => {
+            const paramType = traverse_expr(exprParam, traverseContext);
+            const catalogType = functionCatalog.paramsTypes[index];
+            if (catalogType) {
+                paramType.notNull = catalogType.notNull;
                 traverseContext.constraints.push({
                     expression: expr.getText(),
-                    type1: resultTypes[0].type,
-                    type2: resultType.type
+                    type1: (0, collect_constraints_1.freshVar)(expr.getText(), catalogType.type),
+                    type2: paramType.type
                 });
             }
         });
-        whenTypes.forEach((whenType) => {
-            traverseContext.constraints.push({
-                expression: expr.getText(),
-                type1: (0, collect_constraints_1.freshVar)('INTEGER', 'INTEGER'),
-                type2: whenType.type
-            });
-        });
-        const type = resultTypes[0];
         return {
-            name: extractOriginalSql(expr),
-            type: type.type,
-            notNull: expr.ELSE_() ? resultTypes.every((type) => type.notNull) : false,
-            table: type.table || ''
+            name: expr.getText(),
+            type: functionType,
+            notNull: functionCatalog.returnType.notNull,
+            table: ''
         };
     }
-    throw Error(`traverse_expr not supported:${expr.getText()}`);
+    throw Error(`traverse_expr: function not supported:${function_name}`);
 }
 function extractOriginalSql(rule) {
     var _a, _b;