typesql-cli 0.5.17 → 0.6.1

package/mysql-query-analyzer/collect-constraints.js

@@ -3,20 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.walkSubquery = exports.walkQuerySpecification = exports.generateTypeInfo = exports.analiseQuerySpecification = exports.unionTypeResult = exports.analiseSelectStatement = exports.getDeleteColumns = exports.getUpdateColumns = exports.getInsertColumns = exports.analiseUpdateStatement = exports.analiseDeleteStatement = exports.analiseInsertStatement = exports.analiseTree = exports.freshVar = void 0;
+exports.getFunctionName = exports.isDateLiteral = exports.isDateTimeLiteral = exports.isTimeLiteral = exports.verifyDateTypesCoercion = exports.getVarType = exports.generateTypeInfo = exports.getDeleteColumns = exports.getInsertColumns = exports.getInsertIntoTable = exports.createColumnType = exports.freshVar = void 0;
 const moment_1 = __importDefault(require("moment"));
-const ts_mysql_parser_1 = require("ts-mysql-parser");
 const select_columns_1 = require("./select-columns");
-const parse_1 = require("./parse");
 const unify_1 = require("./unify");
-const infer_param_nullability_1 = require("./infer-param-nullability");
-const describe_query_1 = require("../describe-query");
-const util_1 = require("./util");
 let counter = 0;
 function freshVar(name, typeVar, selectItem, list) {
     const param = {
         kind: 'TypeVar',
-        id: ++counter,
+        id: (++counter).toString(),
         name,
         type: typeVar
     };
@@ -29,285 +24,22 @@ function freshVar(name, typeVar, selectItem, list) {
     return param;
 }
 exports.freshVar = freshVar;
-function analiseTree(tree, context, namedParameters) {
-    var _a, _b, _c;
-    if (tree instanceof ts_mysql_parser_1.QueryContext) {
-        const selectStatement = (_a = tree.simpleStatement()) === null || _a === void 0 ? void 0 : _a.selectStatement();
-        if (selectStatement) {
-            return analiseSelectStatement(selectStatement, context.dbSchema, context.withSchema, namedParameters);
-        }
-        const insertStatement = (_b = tree.simpleStatement()) === null || _b === void 0 ? void 0 : _b.insertStatement();
-        if (insertStatement) {
-            const insertStmt = analiseInsertStatement(insertStatement, context);
-            const TypeInfer = {
-                columns: [],
-                parameters: insertStmt.parameters.map(param => param.columnType)
-            };
-            return TypeInfer;
-        }
-        const updateStatement = (_c = tree.simpleStatement()) === null || _c === void 0 ? void 0 : _c.updateStatement();
-        if (updateStatement) {
-            const updateStmt = analiseUpdateStatement(updateStatement, context.dbSchema, context.withSchema);
-            const TypeInfer = {
-                columns: [],
-                parameters: updateStmt.data.map(param => param.columnType)
-            };
-            return TypeInfer;
-        }
-    }
-    throw Error('invalid type of tree');
-}
-exports.analiseTree = analiseTree;
-function analiseInsertStatement(insertStatement, context) {
-    var _a, _b;
-    const insertColumns = getInsertColumns(insertStatement, context.dbSchema);
-    const allParameters = [];
-    const paramsNullability = {};
-    const exprOrDefaultList = [];
-    const valuesContext = (_a = insertStatement.insertFromConstructor()) === null || _a === void 0 ? void 0 : _a.insertValues().valueList().values()[0];
-    if (valuesContext) {
-        valuesContext.DEFAULT_SYMBOL().forEach(terminalNode => {
-            exprOrDefaultList.push(terminalNode);
-        });
-        valuesContext.expr().forEach(expr => {
-            exprOrDefaultList.push(expr);
-        });
-    }
-    //order the tokens based on sql position
-    exprOrDefaultList.sort((token1, token2) => token1.sourceInterval.a - token2.sourceInterval.a);
-    const insertIntoTable = getInsertIntoTable(insertStatement);
-    const fromColumns = context.dbSchema
-        .filter(c => c.table == insertIntoTable)
-        .map(c => {
-        const col = {
-            table: c.table,
-            column: c.column,
-            columnName: c.column,
-            columnType: c.column_type,
-            columnKey: "",
-            notNull: c.notNull
-        };
-        return col;
-    });
-    context.fromColumns = fromColumns;
-    exprOrDefaultList.forEach((expr, index) => {
-        const column = insertColumns[index];
-        if (expr instanceof ts_mysql_parser_1.ExprContext) {
-            const numberParamsBefore = context.parameters.length;
-            const exprType = walkExpr(context, expr);
-            const paramNullabilityExpr = (0, infer_param_nullability_1.inferParamNullability)(expr);
-            context.parameters.slice(numberParamsBefore).forEach(param => {
-                paramsNullability[param.id] = paramNullabilityExpr.every(n => n) && column.notNull;
-            });
-            context.constraints.push({
-                expression: expr.text,
-                //TODO - CHANGING ORDER SHOULDN'T AFFECT THE TYPE INFERENCE
-                type1: exprType.kind == 'TypeOperator' ? exprType.types[0] : exprType,
-                type2: freshVar(column.column, column.column_type)
-            });
-        }
-    });
-    const updateList = ((_b = insertStatement.insertUpdateList()) === null || _b === void 0 ? void 0 : _b.updateList().updateElement()) || [];
-    updateList.forEach(updateElement => {
-        const columnName = updateElement.columnRef().text;
-        const field = (0, select_columns_1.splitName)(columnName);
-        const expr = updateElement.expr();
-        if (expr) {
-            const numberParamsBefore = context.parameters.length;
-            const exprType = walkExpr(context, expr);
-            const column = (0, select_columns_1.findColumn2)(field, insertIntoTable, context.dbSchema);
-            context.parameters.slice(numberParamsBefore).forEach(param => {
-                paramsNullability[param.id] = column.notNull;
-            });
-            context.constraints.push({
-                expression: expr.text,
-                type1: exprType,
-                type2: freshVar(column.column, column.column_type)
-            });
-        }
-    });
-    const insertQueryExpression = insertStatement.insertQueryExpression();
-    if (insertQueryExpression) {
-        const numberParamsBefore = context.parameters.length;
-        const exprTypes = walkInsertQueryExpression(insertQueryExpression, context);
-        exprTypes.types.forEach((type, index) => {
-            const column = insertColumns[index];
-            if (type.kind == 'TypeVar') {
-                paramsNullability[type.id] = column.notNull;
-            }
-            context.constraints.push({
-                expression: insertQueryExpression.text,
-                type1: type,
-                type2: freshVar(column.column, column.column_type)
-            });
-        });
-        const paramNullabilityExpr = (0, infer_param_nullability_1.inferParamNullabilityQuery)(insertQueryExpression);
-        context.parameters.slice(numberParamsBefore).forEach((param, index) => {
-            if (paramsNullability[param.id] == null) {
-                paramsNullability[param.id] = paramNullabilityExpr[index];
-            }
-        });
-    }
-    const typeInfo = generateTypeInfo(context.parameters, context.constraints);
-    typeInfo.forEach((param, index) => {
-        const paramId = context.parameters[index].id;
-        allParameters.push({
-            name: 'param' + (allParameters.length + 1),
-            columnType: (0, describe_query_1.verifyNotInferred)(param),
-            notNull: paramsNullability[paramId]
-        });
-    });
-    const typeInferenceResult = {
-        kind: 'Insert',
-        parameters: allParameters
-    };
-    return typeInferenceResult;
-}
-exports.analiseInsertStatement = analiseInsertStatement;
-function walkInsertQueryExpression(insertQueryExpression, context) {
-    const queryExpressionOrParens = insertQueryExpression.queryExpressionOrParens();
-    return walkQueryExpressionOrParens(queryExpressionOrParens, context);
-}
-function walkQueryExpressionOrParens(queryExpressionOrParens, context) {
-    const queryExpression = queryExpressionOrParens.queryExpression();
-    if (queryExpression) {
-        return walkQueryExpression(queryExpression, context);
-    }
-    const queryEpressionParens = queryExpressionOrParens.queryExpressionParens();
-    if (queryEpressionParens) {
-        return walkQueryExpressionParens(queryEpressionParens);
-    }
-    throw Error("walkQueryExpressionOrParens");
-}
-function walkQueryExpression(queryExpression, context) {
-    const queryExpressionBody = queryExpression.queryExpressionBody();
-    if (queryExpressionBody) {
-        return walkQueryExpressionBody(queryExpressionBody, context);
-    }
-    const queryExpressionParens = queryExpression.queryExpressionParens();
-    if (queryExpressionParens) {
-        return walkQueryExpressionParens(queryExpressionParens);
-    }
-    throw Error("walkQueryExpression");
-}
-function walkQueryExpressionParens(queryExpressionParens) {
-    throw Error("walkQueryExpressionParens not implemented:" + queryExpressionParens.text);
-}
-function walkQueryExpressionBody(queryExpressionBody, context) {
-    const childQueryExpressionBody = queryExpressionBody.queryExpressionBody();
-    if (childQueryExpressionBody) {
-        return walkQueryExpressionBody(childQueryExpressionBody, context);
-    }
-    const queryExpressionParensList = queryExpressionBody.queryExpressionParens();
-    queryExpressionParensList.forEach(queryExpressionParens => {
-        return walkQueryExpressionParens(queryExpressionParens);
-    });
-    const querySpecification = queryExpressionBody.querySpecification();
-    if (querySpecification) {
-        return walkQuerySpecification(context, querySpecification);
-    }
-    throw Error("walkQueryExpressionBody");
-}
-function analiseDeleteStatement(deleteStatement, dbSchema, withSchema) {
-    var _a;
-    const whereExpr = (_a = deleteStatement.whereClause()) === null || _a === void 0 ? void 0 : _a.expr();
-    const deleteColumns = getDeleteColumns(deleteStatement, dbSchema);
-    const allParameters = [];
-    if (whereExpr) {
-        const context = {
-            fromColumns: deleteColumns,
-            parameters: [],
-            constraints: [],
-            dbSchema,
-            withSchema
-        };
-        walkExpr(context, whereExpr);
-        const typeInfo = generateTypeInfo(context.parameters, context.constraints);
-        const paramNullability = (0, infer_param_nullability_1.inferParamNullability)(whereExpr);
-        typeInfo.forEach((param, paramIndex) => {
-            allParameters.push({
-                name: 'param' + (allParameters.length + 1),
-                columnType: (0, describe_query_1.verifyNotInferred)(param),
-                notNull: paramNullability[paramIndex]
-            });
-        });
-    }
-    const typeInferenceResult = {
-        kind: 'Delete',
-        parameters: allParameters
-    };
-    return typeInferenceResult;
-}
-exports.analiseDeleteStatement = analiseDeleteStatement;
-function analiseUpdateStatement(updateStatement, dbSchema, withSchema) {
-    var _a;
-    const updateElement = updateStatement.updateList().updateElement();
-    const updateColumns = getUpdateColumns(updateStatement, dbSchema);
-    const dataParameters = [];
-    const whereParameters = [];
-    updateElement.forEach(updateElement => {
-        const expr = updateElement.expr();
-        if (expr) {
-            const context = {
-                dbSchema,
-                withSchema,
-                parameters: [],
-                constraints: [],
-                fromColumns: updateColumns
-            };
-            const result = walkExpr(context, expr);
-            const columnName = updateElement.columnRef().text;
-            const field = (0, select_columns_1.splitName)(columnName);
-            const column = (0, select_columns_1.findColumn)(field, updateColumns);
-            context.constraints.push({
-                expression: updateStatement.text,
-                type1: result,
-                type2: freshVar(column.table, column.columnType)
-            });
-            const typeInfo = generateTypeInfo(context.parameters, context.constraints);
-            const paramNullabilityExpr = (0, infer_param_nullability_1.inferParamNullability)(expr);
-            typeInfo.forEach(param => {
-                dataParameters.push({
-                    name: column.columnName,
-                    columnType: (0, describe_query_1.verifyNotInferred)(param),
-                    notNull: paramNullabilityExpr.every(n => n) && column.notNull
-                });
-            });
-        }
-    });
-    const whereExpr = (_a = updateStatement.whereClause()) === null || _a === void 0 ? void 0 : _a.expr();
-    if (whereExpr) {
-        const context = {
-            dbSchema,
-            withSchema,
-            parameters: [],
-            constraints: [],
-            fromColumns: updateColumns
-        };
-        walkExpr(context, whereExpr);
-        const typeInfo = generateTypeInfo(context.parameters, context.constraints);
-        const paramNullability = (0, infer_param_nullability_1.inferParamNullability)(whereExpr);
-        typeInfo.forEach((param, paramIndex) => {
-            whereParameters.push({
-                name: 'param' + (whereParameters.length + 1),
-                columnType: (0, describe_query_1.verifyNotInferred)(param),
-                notNull: paramNullability[paramIndex]
-            });
-        });
-    }
-    const typeInferenceResult = {
-        kind: 'Update',
-        data: dataParameters,
-        parameters: whereParameters
+function createColumnType(col) {
+    const columnType = {
+        kind: 'TypeVar',
+        id: col.columnType.id,
+        name: col.columnName,
+        type: col.columnType.type
     };
-    return typeInferenceResult;
+    return columnType;
 }
-exports.analiseUpdateStatement = analiseUpdateStatement;
+exports.createColumnType = createColumnType;
 function getInsertIntoTable(insertStatement) {
     const insertIntoTable = (0, select_columns_1.splitName)(insertStatement.tableRef().text).name;
     return insertIntoTable;
 }
-function getInsertColumns(insertStatement, dbSchema) {
+exports.getInsertIntoTable = getInsertIntoTable;
+function getInsertColumns(insertStatement, fromColumns) {
     var _a;
     const insertIntoTable = getInsertIntoTable(insertStatement);
     const insertFields = insertStatement.insertFromConstructor() ||
@@ -316,39 +48,21 @@ function getInsertColumns(insertStatement, dbSchema) {
         const colRef = insertIdentifier.columnRef();
         if (colRef) {
             const fieldName = (0, select_columns_1.splitName)(colRef.text);
-            const column = (0, select_columns_1.findColumn2)(fieldName, insertIntoTable, dbSchema);
+            const column = (0, select_columns_1.findColumn)(fieldName, fromColumns);
             return column;
         }
         throw Error('Invalid sql');
     });
     //check insert stmt without fields (only values). Ex.: insert into mytable values()
     if (!fields) {
-        return dbSchema.filter(column => column.table == insertIntoTable);
+        return fromColumns.filter(column => column.table == insertIntoTable);
     }
     return fields;
 }
 exports.getInsertColumns = getInsertColumns;
-function getUpdateColumns(updateStatement, dbSchema) {
-    const insertIntoTable = (0, select_columns_1.splitName)(updateStatement.tableReferenceList().tableReference()[0].text).name;
-    const columns = dbSchema
-        .filter(col => col.table == insertIntoTable)
-        .map(col => {
-        const colDef = {
-            table: col.table,
-            column: col.column,
-            columnName: col.column,
-            columnType: col.column_type,
-            columnKey: col.columnKey,
-            notNull: col.notNull,
-            tableAlias: ''
-        };
-        return colDef;
-    });
-    return columns;
-}
-exports.getUpdateColumns = getUpdateColumns;
 function getDeleteColumns(deleteStatement, dbSchema) {
     var _a, _b;
+    //TODO - Use extractColumnsFromTableReferences
     const tableNameStr = (_a = deleteStatement.tableRef()) === null || _a === void 0 ? void 0 : _a.text;
     const tableAlias = (_b = deleteStatement.tableAlias()) === null || _b === void 0 ? void 0 : _b.text;
     const tableName = (0, select_columns_1.splitName)(tableNameStr).name;
@@ -356,523 +70,18 @@ function getDeleteColumns(deleteStatement, dbSchema) {
         .filter(col => col.table == tableName)
         .map(col => {
         const colDef = {
-            table: col.table,
-            column: col.column,
+            table: tableNameStr,
+            tableAlias: tableAlias,
             columnName: col.column,
-            columnType: col.column_type,
+            columnType: { kind: "TypeVar", id: col.column, name: col.column, type: col.column_type },
             columnKey: col.columnKey,
-            notNull: col.notNull,
-            tableAlias: tableAlias
+            notNull: col.notNull
         };
         return colDef;
     });
     return columns;
 }
 exports.getDeleteColumns = getDeleteColumns;
-function analiseSelectStatement(selectStatement, dbSchema, withSchema, namedParameters) {
-    const querySpec = (0, parse_1.getQuerySpecificationsFromSelectStatement)(selectStatement);
-    const fromColumns = (0, select_columns_1.getColumnsFrom)(querySpec[0], dbSchema, withSchema);
-    let result = analiseQuerySpecification(querySpec[0], dbSchema, withSchema, fromColumns, namedParameters);
-    for (let index = 1; index < querySpec.length; index++) {
-        const unionQuery = querySpec[index];
-        const fromColumns2 = (0, select_columns_1.getColumnsFrom)(unionQuery, dbSchema, withSchema);
-        const result2 = analiseQuerySpecification(unionQuery, dbSchema, withSchema, fromColumns2, namedParameters);
-        result = unionResult(result, result2);
-    }
-    return result;
-}
-exports.analiseSelectStatement = analiseSelectStatement;
-function unionResult(typeInference1, typeInference2) {
-    const resultColumnTypes = typeInference1.columns.map((col1, index) => {
-        const col2 = typeInference2.columns[index];
-        const resultType = unionTypeResult(col1, col2);
-        return resultType;
-    });
-    return {
-        columns: resultColumnTypes,
-        parameters: [...typeInference1.parameters, ...typeInference2.parameters] //TODO-INVERSE?
-    };
-}
-function unionTypeResult(type1, type2) {
-    //Gernerated with tests\check-mysql-inference.ts
-    const typeMapping = {
-        "decimal_tinyint": "decimal",
-        "decimal_smallint": "decimal",
-        "decimal_int": "decimal",
-        "decimal_float": "double",
-        "decimal_double": "double",
-        "decimal_timestamp": "varchar",
-        "decimal_bigint": "decimal",
-        "decimal_mediumint": "decimal",
-        "decimal_date": "varchar",
-        "decimal_time": "varchar",
-        "decimal_datetime": "varchar",
-        "decimal_year": "decimal",
-        "decimal_varchar": "varchar",
-        "decimal_bit": "decimal",
-        "decimal_json": "varbinary",
-        "decimal_enum": "varchar",
-        "decimal_set": "varchar",
-        "decimal_tinyblob": "text",
-        "decimal_mediumblob": "text",
-        "decimal_longblob": "longtext",
-        "decimal_blob": "text",
-        "decimal_tinytext": "text",
-        "decimal_mediumtext": "text",
-        "decimal_longtext": "longtext",
-        "decimal_text": "text",
-        "decimal_varbinary": "varbinary",
-        "decimal_binary": "binary",
-        "decimal_char": "binary",
-        "decimal_geometry": "varbinary",
-        "tinyint_smallint": "smallint",
-        "tinyint_int": "int",
-        "tinyint_float": "float",
-        "tinyint_double": "double",
-        "tinyint_timestamp": "varchar",
-        "tinyint_bigint": "bigint",
-        "tinyint_mediumint": "mediumint",
-        "tinyint_date": "varchar",
-        "tinyint_time": "varchar",
-        "tinyint_datetime": "varchar",
-        "tinyint_year": "tinyint",
-        "tinyint_varchar": "varchar",
-        "tinyint_bit": "decimal",
-        "tinyint_json": "varbinary",
-        "tinyint_enum": "varchar",
-        "tinyint_set": "varchar",
-        "tinyint_tinyblob": "text",
-        "tinyint_mediumblob": "text",
-        "tinyint_longblob": "longtext",
-        "tinyint_blob": "text",
-        "tinyint_tinytext": "text",
-        "tinyint_mediumtext": "text",
-        "tinyint_longtext": "longtext",
-        "tinyint_text": "text",
-        "tinyint_varbinary": "varbinary",
-        "tinyint_binary": "binary",
-        "tinyint_char": "binary",
-        "tinyint_geometry": "varbinary",
-        "smallint_int": "int",
-        "smallint_float": "float",
-        "smallint_double": "double",
-        "smallint_timestamp": "varchar",
-        "smallint_bigint": "bigint",
-        "smallint_mediumint": "mediumint",
-        "smallint_date": "varchar",
-        "smallint_time": "varchar",
-        "smallint_datetime": "varchar",
-        "smallint_year": "smallint",
-        "smallint_varchar": "varchar",
-        "smallint_bit": "decimal",
-        "smallint_json": "varbinary",
-        "smallint_enum": "varchar",
-        "smallint_set": "varchar",
-        "smallint_tinyblob": "text",
-        "smallint_mediumblob": "text",
-        "smallint_longblob": "longtext",
-        "smallint_blob": "text",
-        "smallint_tinytext": "text",
-        "smallint_mediumtext": "text",
-        "smallint_longtext": "longtext",
-        "smallint_text": "text",
-        "smallint_varbinary": "varbinary",
-        "smallint_binary": "binary",
-        "smallint_char": "binary",
-        "smallint_geometry": "varbinary",
-        "int_float": "double",
-        "int_double": "double",
-        "int_timestamp": "varchar",
-        "int_bigint": "bigint",
-        "int_mediumint": "int",
-        "int_date": "varchar",
-        "int_time": "varchar",
-        "int_datetime": "varchar",
-        "int_year": "int",
-        "int_varchar": "varchar",
-        "int_bit": "decimal",
-        "int_json": "varbinary",
-        "int_enum": "varchar",
-        "int_set": "varchar",
-        "int_tinyblob": "text",
-        "int_mediumblob": "text",
-        "int_longblob": "longtext",
-        "int_blob": "text",
-        "int_tinytext": "text",
-        "int_mediumtext": "text",
-        "int_longtext": "longtext",
-        "int_text": "text",
-        "int_varbinary": "varbinary",
-        "int_binary": "binary",
-        "int_char": "binary",
-        "int_geometry": "varbinary",
-        "float_double": "double",
-        "float_timestamp": "varchar",
-        "float_bigint": "float",
-        "float_mediumint": "float",
-        "float_date": "varchar",
-        "float_time": "varchar",
-        "float_datetime": "varchar",
-        "float_year": "float",
-        "float_varchar": "varchar",
-        "float_bit": "double",
-        "float_json": "varbinary",
-        "float_enum": "varchar",
-        "float_set": "varchar",
-        "float_tinyblob": "text",
-        "float_mediumblob": "text",
-        "float_longblob": "longtext",
-        "float_blob": "text",
-        "float_tinytext": "text",
-        "float_mediumtext": "text",
-        "float_longtext": "longtext",
-        "float_text": "text",
-        "float_varbinary": "varbinary",
-        "float_binary": "binary",
-        "float_char": "binary",
-        "float_geometry": "varbinary",
-        "double_timestamp": "varchar",
-        "double_bigint": "double",
-        "double_mediumint": "double",
-        "double_date": "varchar",
-        "double_time": "varchar",
-        "double_datetime": "varchar",
-        "double_year": "double",
-        "double_varchar": "varchar",
-        "double_bit": "double",
-        "double_json": "varbinary",
-        "double_enum": "varchar",
-        "double_set": "varchar",
-        "double_tinyblob": "text",
-        "double_mediumblob": "text",
-        "double_longblob": "longtext",
-        "double_blob": "text",
-        "double_tinytext": "text",
-        "double_mediumtext": "text",
-        "double_longtext": "longtext",
-        "double_text": "text",
-        "double_varbinary": "varbinary",
-        "double_binary": "binary",
-        "double_char": "binary",
-        "double_geometry": "varbinary",
-        "timestamp_bigint": "varchar",
-        "timestamp_mediumint": "varchar",
-        "timestamp_date": "datetime",
-        "timestamp_time": "datetime",
-        "timestamp_datetime": "datetime",
-        "timestamp_year": "varchar",
-        "timestamp_varchar": "varchar",
-        "timestamp_bit": "varbinary",
-        "timestamp_json": "varbinary",
-        "timestamp_enum": "varchar",
-        "timestamp_set": "varchar",
-        "timestamp_tinyblob": "text",
-        "timestamp_mediumblob": "text",
-        "timestamp_longblob": "longtext",
-        "timestamp_blob": "text",
-        "timestamp_tinytext": "text",
-        "timestamp_mediumtext": "text",
-        "timestamp_longtext": "longtext",
-        "timestamp_text": "text",
-        "timestamp_varbinary": "varbinary",
-        "timestamp_binary": "binary",
-        "timestamp_char": "binary",
-        "timestamp_geometry": "varbinary",
-        "bigint_mediumint": "bigint",
-        "bigint_date": "varchar",
-        "bigint_time": "varchar",
-        "bigint_datetime": "varchar",
-        "bigint_year": "bigint",
-        "bigint_varchar": "varchar",
-        "bigint_bit": "decimal",
-        "bigint_json": "varbinary",
-        "bigint_enum": "varchar",
-        "bigint_set": "varchar",
-        "bigint_tinyblob": "text",
-        "bigint_mediumblob": "text",
-        "bigint_longblob": "longtext",
-        "bigint_blob": "text",
-        "bigint_tinytext": "text",
-        "bigint_mediumtext": "text",
-        "bigint_longtext": "longtext",
-        "bigint_text": "text",
-        "bigint_varbinary": "varbinary",
-        "bigint_binary": "binary",
-        "bigint_char": "binary",
-        "bigint_geometry": "varbinary",
-        "mediumint_date": "varchar",
-        "mediumint_time": "varchar",
-        "mediumint_datetime": "varchar",
-        "mediumint_year": "mediumint",
-        "mediumint_varchar": "varchar",
-        "mediumint_bit": "decimal",
-        "mediumint_json": "varbinary",
-        "mediumint_enum": "varchar",
-        "mediumint_set": "varchar",
-        "mediumint_tinyblob": "text",
-        "mediumint_mediumblob": "text",
-        "mediumint_longblob": "longtext",
-        "mediumint_blob": "text",
-        "mediumint_tinytext": "text",
-        "mediumint_mediumtext": "text",
-        "mediumint_longtext": "longtext",
-        "mediumint_text": "text",
-        "mediumint_varbinary": "varbinary",
-        "mediumint_binary": "binary",
-        "mediumint_char": "binary",
-        "mediumint_geometry": "varbinary",
-        "date_time": "datetime",
-        "date_datetime": "datetime",
-        "date_year": "varchar",
-        "date_varchar": "varchar",
-        "date_bit": "varbinary",
-        "date_json": "varbinary",
-        "date_enum": "varchar",
-        "date_set": "varchar",
-        "date_tinyblob": "text",
-        "date_mediumblob": "text",
-        "date_longblob": "longtext",
-        "date_blob": "text",
-        "date_tinytext": "text",
-        "date_mediumtext": "text",
-        "date_longtext": "longtext",
-        "date_text": "text",
-        "date_varbinary": "varbinary",
-        "date_binary": "binary",
-        "date_char": "binary",
-        "date_geometry": "varbinary",
-        "time_datetime": "datetime",
-        "time_year": "varchar",
-        "time_varchar": "varchar",
-        "time_bit": "varbinary",
-        "time_json": "varbinary",
-        "time_enum": "varchar",
-        "time_set": "varchar",
-        "time_tinyblob": "text",
-        "time_mediumblob": "text",
-        "time_longblob": "longtext",
-        "time_blob": "text",
-        "time_tinytext": "text",
-        "time_mediumtext": "text",
-        "time_longtext": "longtext",
-        "time_text": "text",
-        "time_varbinary": "varbinary",
-        "time_binary": "binary",
-        "time_char": "binary",
-        "time_geometry": "varbinary",
-        "datetime_year": "varchar",
-        "datetime_varchar": "varchar",
-        "datetime_bit": "varbinary",
-        "datetime_json": "varbinary",
-        "datetime_enum": "varchar",
-        "datetime_set": "varchar",
-        "datetime_tinyblob": "text",
-        "datetime_mediumblob": "text",
-        "datetime_longblob": "longtext",
-        "datetime_blob": "text",
-        "datetime_tinytext": "text",
-        "datetime_mediumtext": "text",
-        "datetime_longtext": "longtext",
-        "datetime_text": "text",
-        "datetime_varbinary": "varbinary",
-        "datetime_binary": "binary",
-        "datetime_char": "binary",
-        "datetime_geometry": "varbinary",
-        "year_varchar": "varchar",
-        "year_bit": "bigint",
-        "year_json": "varbinary",
-        "year_enum": "varchar",
-        "year_set": "varchar",
-        "year_tinyblob": "text",
-        "year_mediumblob": "text",
-        "year_longblob": "longtext",
-        "year_blob": "text",
-        "year_tinytext": "text",
-        "year_mediumtext": "text",
-        "year_longtext": "longtext",
-        "year_text": "text",
-        "year_varbinary": "varbinary",
-        "year_binary": "binary",
-        "year_char": "binary",
-        "year_geometry": "varbinary",
-        "varchar_bit": "varbinary",
-        "varchar_json": "varbinary",
-        "varchar_enum": "varchar",
-        "varchar_set": "varchar",
-        "varchar_tinyblob": "text",
-        "varchar_mediumblob": "text",
-        "varchar_longblob": "longtext",
-        "varchar_blob": "text",
-        "varchar_tinytext": "text",
-        "varchar_mediumtext": "text",
-        "varchar_longtext": "longtext",
-        "varchar_text": "text",
-        "varchar_varbinary": "varbinary",
-        "varchar_binary": "varbinary",
-        "varchar_char": "varchar",
-        "varchar_geometry": "varbinary",
-        "bit_json": "varbinary",
-        "bit_enum": "varbinary",
-        "bit_set": "varbinary",
-        "bit_tinyblob": "text",
-        "bit_mediumblob": "text",
-        "bit_longblob": "longtext",
-        "bit_blob": "text",
-        "bit_tinytext": "tinytext",
-        "bit_mediumtext": "mediumtext",
-        "bit_longtext": "longtext",
-        "bit_text": "text",
-        "bit_varbinary": "varbinary",
-        "bit_binary": "binary",
-        "bit_char": "binary",
-        "bit_geometry": "varbinary",
-        "json_enum": "varbinary",
-        "json_set": "varbinary",
-        "json_tinyblob": "longtext",
-        "json_mediumblob": "longtext",
-        "json_longblob": "longtext",
-        "json_blob": "longtext",
-        "json_tinytext": "longtext",
-        "json_mediumtext": "longtext",
-        "json_longtext": "longtext",
-        "json_text": "longtext",
-        "json_varbinary": "varbinary",
-        "json_binary": "varbinary",
-        "json_char": "varbinary",
-        "json_geometry": "varbinary",
-        "enum_set": "varchar",
-        "enum_tinyblob": "text",
-        "enum_mediumblob": "text",
-        "enum_longblob": "longtext",
-        "enum_blob": "text",
-        "enum_tinytext": "text",
-        "enum_mediumtext": "text",
-        "enum_longtext": "longtext",
-        "enum_text": "text",
-        "enum_varbinary": "varbinary",
-        "enum_binary": "binary",
-        "enum_char": "binary",
-        "enum_geometry": "varbinary",
-        "set_tinyblob": "text",
-        "set_mediumblob": "text",
-        "set_longblob": "longtext",
-        "set_blob": "text",
-        "set_tinytext": "text",
-        "set_mediumtext": "text",
-        "set_longtext": "longtext",
-        "set_text": "text",
-        "set_varbinary": "varbinary",
-        "set_binary": "binary",
-        "set_char": "binary",
-        "set_geometry": "varbinary",
-        "tinyblob_mediumblob": "text",
-        "tinyblob_longblob": "longtext",
-        "tinyblob_blob": "text",
-        "tinyblob_tinytext": "tinytext",
-        "tinyblob_mediumtext": "mediumtext",
-        "tinyblob_longtext": "longtext",
-        "tinyblob_text": "text",
-        "tinyblob_varbinary": "text",
-        "tinyblob_binary": "text",
-        "tinyblob_char": "text",
-        "tinyblob_geometry": "longtext",
-        "mediumblob_longblob": "longtext",
-        "mediumblob_blob": "text",
-        "mediumblob_tinytext": "text",
-        "mediumblob_mediumtext": "mediumtext",
-        "mediumblob_longtext": "longtext",
-        "mediumblob_text": "text",
-        "mediumblob_varbinary": "text",
-        "mediumblob_binary": "text",
-        "mediumblob_char": "text",
-        "mediumblob_geometry": "longtext",
-        "longblob_blob": "longtext",
-        "longblob_tinytext": "longtext",
-        "longblob_mediumtext": "longtext",
-        "longblob_longtext": "longtext",
-        "longblob_text": "longtext",
-        "longblob_varbinary": "longtext",
-        "longblob_binary": "longtext",
-        "longblob_char": "longtext",
-        "longblob_geometry": "longtext",
-        "blob_tinytext": "text",
-        "blob_mediumtext": "mediumtext",
-        "blob_longtext": "longtext",
-        "blob_text": "text",
-        "blob_varbinary": "text",
-        "blob_binary": "text",
-        "blob_char": "text",
-        "blob_geometry": "longtext",
-        "tinytext_mediumtext": "text",
-        "tinytext_longtext": "longtext",
-        "tinytext_text": "text",
-        "tinytext_varbinary": "tinytext",
-        "tinytext_binary": "tinytext",
-        "tinytext_char": "text",
-        "tinytext_geometry": "longtext",
-        "mediumtext_longtext": "longtext",
-        "mediumtext_text": "text",
-        "mediumtext_varbinary": "mediumtext",
-        "mediumtext_binary": "mediumtext",
-        "mediumtext_char": "text",
-        "mediumtext_geometry": "longtext",
-        "longtext_text": "longtext",
-        "longtext_varbinary": "longtext",
-        "longtext_binary": "longtext",
-        "longtext_char": "longtext",
-        "longtext_geometry": "longtext",
-        "text_varbinary": "text",
-        "text_binary": "text",
-        "text_char": "text",
-        "text_geometry": "longtext",
-        "varbinary_binary": "varbinary",
-        "varbinary_char": "varbinary",
-        "varbinary_geometry": "varbinary",
-        "binary_char": "binary",
-        "binary_geometry": "varbinary",
-        "char_geometry": "varbinary"
-    };
-    if (type1 == type2)
-        return type1;
-    //@ts-ignore
-    //ex. tinyint_smallint or smallint_tinyint
-    return typeMapping[type1 + "_" + type2] || typeMapping[type2 + "_" + type1];
-}
-exports.unionTypeResult = unionTypeResult;
-function analiseQuerySpecification(querySpec, dbSchema, withSchema, fromColumns, namedParameters) {
-    const context = {
-        dbSchema,
-        withSchema,
-        fromColumns,
-        parameters: [],
-        constraints: [],
-    };
-    const queryTypes = walkQuerySpecification(context, querySpec);
-    const paramIndexes = (0, util_1.getParameterIndexes)(namedParameters.slice(0, context.parameters.length)); //for [a, a, b, a] will return a: [0, 1, 3]; b: [2]
-    paramIndexes.forEach(paramIndex => {
-        (0, util_1.getPairWise)(paramIndex.indexes, (cur, next) => {
-            context.constraints.push({
-                expression: paramIndex.paramName,
-                type1: context.parameters[cur],
-                type2: context.parameters[next]
-            });
-        });
-    });
-    // console.log("namedNodes");
-    // console.dir(namedNodes, { depth: null });
-    // console.log("constraints2=");
-    // console.dir(constraints, { depth: null });
-    const substitutions = {};
-    (0, unify_1.unify)(context.constraints, substitutions);
-    const parameters = context.parameters.map(param => getVarType(substitutions, param));
-    const columnTypes = queryTypes.types.map(param => getVarType(substitutions, param));
-    const querySpecResult = {
-        parameters: parameters,
-        columns: columnTypes
-    };
-    return querySpecResult;
-}
-exports.analiseQuerySpecification = analiseQuerySpecification;
 function generateTypeInfo(namedNodes, constraints) {
     const substitutions = {};
     (0, unify_1.unify)(constraints, substitutions);
@@ -882,897 +91,26 @@ function generateTypeInfo(namedNodes, constraints) {
 exports.generateTypeInfo = generateTypeInfo;
 function getVarType(substitutions, typeVar) {
     if (typeVar.kind == 'TypeVar') {
-        const type = substitutions[typeVar.id];
-        if (!type) {
-            return typeVar.type;
-        }
-        const resultType = typeVar.list ? type.type + '[]' : type.type;
+        // if (typeVar.type != '?') {
+        //     return typeVar.type;
+        // }
+        const subs = substitutions[typeVar.id];
+        if (subs) {
+            if (subs.id != typeVar.id) {
+                return getVarType(substitutions, subs);
+            }
+            const resultType = subs.list || typeVar.list ? subs.type + '[]' : subs.type;
+            return resultType;
+        }
+        // if (!subs) {
+        //     return typeVar.type as MySqlType;
+        // }
+        const resultType = typeVar.list ? typeVar.type + '[]' : typeVar.type;
         return resultType;
     }
     return '?';
 }
-function walkQuerySpecification(context, querySpec) {
-    const listType = [];
-    const fromClause = querySpec.fromClause();
-    if (fromClause) {
-        const subqueryColumns = (0, select_columns_1.getColumnsFrom)(querySpec, context.dbSchema, context.withSchema);
-        const newContext = Object.assign(Object.assign({}, context), { fromColumns: subqueryColumns });
-        walkFromClause(newContext, fromClause);
-    }
-    if (querySpec.selectItemList().MULT_OPERATOR()) {
-        context.fromColumns.forEach(col => {
-            const colType = freshVar(col.columnName, col.columnType);
-            listType.push(colType);
-        });
-    }
-    querySpec.selectItemList().selectItem().forEach(selectItem => {
-        var _a, _b;
-        const tableWild = selectItem.tableWild(); //ex. t1.*
-        if (tableWild) {
-            tableWild.identifier().forEach(tabWild => {
-                if (tableWild.MULT_OPERATOR()) {
-                    const prefix = tabWild.text;
-                    const columns = (0, select_columns_1.selectAllColumns)(prefix, context.fromColumns);
-                    columns.forEach(col => {
-                        const colType = freshVar(col.columnName, col.columnType);
-                        listType.push(colType);
-                    });
-                }
-            });
-        }
-        else {
-            const expr = selectItem.expr();
-            if (expr) {
-                const exprType = walkExpr(context, expr);
-                if (exprType.kind == 'TypeOperator') {
-                    const subqueryType = exprType.types[0];
-                    listType.push(subqueryType);
-                }
-                else {
-                    listType.push(exprType);
-                    const subQueryContext = (0, infer_param_nullability_1.getParentContext)(expr, ts_mysql_parser_1.SubqueryContext);
-                    const alias = ((_b = (_a = selectItem.selectAlias()) === null || _a === void 0 ? void 0 : _a.identifier()) === null || _b === void 0 ? void 0 : _b.text) || undefined;
-                    if (alias && !subQueryContext) {
-                        //IF NOT A SUBQUERY THIS ALIAS CAN BE USED IN THE HAVING CLAUSE
-                        context.constraints.push({
-                            expression: expr.text,
-                            mostGeneralType: true,
-                            aliasConstraint: true,
-                            type1: exprType,
-                            type2: freshVar(alias, exprType.type)
-                        });
-                    }
-                }
-            }
-        }
-    });
-    const whereClause = querySpec.whereClause();
-    //TODO - HAVING, BLAH
-    if (whereClause) {
-        const whereExpr = whereClause === null || whereClause === void 0 ? void 0 : whereClause.expr();
-        walkExpr(context, whereExpr);
-    }
-    const havingClause = querySpec.havingClause();
-    if (havingClause) {
-        context.havingExpr = true;
-        walkHavingClause(havingClause, context);
-        context.havingExpr = false;
-    }
-    const typeOperator = {
-        kind: 'TypeOperator',
-        selectItem: true,
-        types: listType
-    };
-    return typeOperator;
-}
-exports.walkQuerySpecification = walkQuerySpecification;
-function walkFromClause(context, fromClause) {
-    var _a;
-    const tableReferences = (_a = fromClause.tableReferenceList()) === null || _a === void 0 ? void 0 : _a.tableReference();
-    tableReferences === null || tableReferences === void 0 ? void 0 : tableReferences.forEach(tabeRef => {
-        tabeRef.joinedTable().forEach(joinedTable => {
-            const onExpr = joinedTable.expr();
-            if (onExpr) {
-                walkExpr(context, onExpr);
-            }
-        });
-    });
-}
-function walkHavingClause(havingClause, context) {
-    const havingExpr = havingClause.expr();
-    walkExpr(context, havingExpr);
-}
-function walkExpr(context, expr) {
-    if (expr instanceof ts_mysql_parser_1.ExprIsContext) {
-        const boolPri = expr.boolPri();
-        const boolPriType = walkBoolPri(context, boolPri);
-        return boolPriType;
-    }
-    if (expr instanceof ts_mysql_parser_1.ExprNotContext) {
-        return freshVar(expr.text, 'tinyint');
-        ;
-    }
-    if (expr instanceof ts_mysql_parser_1.ExprAndContext || expr instanceof ts_mysql_parser_1.ExprXorContext || expr instanceof ts_mysql_parser_1.ExprOrContext) {
-        const exprLeft = expr.expr()[0];
-        walkExpr(context, exprLeft);
-        const exprRight = expr.expr()[1];
-        walkExpr(context, exprRight);
-        return freshVar(expr.text, 'tinyint');
-    }
-    throw Error('invalid type');
-}
-function walkBoolPri(context, boolPri) {
-    if (boolPri instanceof ts_mysql_parser_1.PrimaryExprPredicateContext) {
-        const predicate = boolPri.predicate();
-        const predicateType = walkPredicate(context, predicate);
-        return predicateType;
-    }
-    if (boolPri instanceof ts_mysql_parser_1.PrimaryExprIsNullContext) {
-        const boolPri2 = boolPri.boolPri();
-        walkBoolPri(context, boolPri2);
-        return freshVar(boolPri.text, '?');
-    }
-    if (boolPri instanceof ts_mysql_parser_1.PrimaryExprCompareContext) {
-        const compareLeft = boolPri.boolPri();
-        const compareRight = boolPri.predicate();
-        const typeLeft = walkBoolPri(context, compareLeft);
-        const typeRight = walkPredicate(context, compareRight);
-        context.constraints.push({
-            expression: boolPri.text,
-            type1: typeLeft,
-            type2: typeRight
-        });
-        return freshVar(boolPri.text, 'tinyint');
-    }
-    if (boolPri instanceof ts_mysql_parser_1.PrimaryExprAllAnyContext) {
-        const compareLeft = boolPri.boolPri();
-        const compareRight = boolPri.subquery();
-        const typeLeft = walkBoolPri(context, compareLeft);
-        const typeRight = walkSubquery(context, compareRight);
-        context.constraints.push({
-            expression: boolPri.text,
-            type1: typeLeft,
-            type2: typeRight
-        });
-        return freshVar(boolPri.text, 'tinyint');
-    }
-    throw Error('invalid sql');
-}
-function walkPredicate(context, predicate) {
-    const bitExpr = predicate.bitExpr()[0];
-    const bitExprType = walkBitExpr(context, bitExpr);
-    const predicateOperations = predicate.predicateOperations();
-    if (predicateOperations) {
-        const rightType = walkpredicateOperations(context, bitExprType, predicateOperations);
-        context.constraints.push({
-            expression: predicateOperations.text,
-            type1: bitExprType,
-            type2: rightType,
-            mostGeneralType: true
-        });
-        return rightType;
-    }
-    // return freshVar(predicateOperations.text, 'tinyint');
-    return bitExprType;
-}
-function walkpredicateOperations(context, parentType, predicateOperations) {
-    if (predicateOperations instanceof ts_mysql_parser_1.PredicateExprInContext) {
-        const subquery = predicateOperations.subquery();
-        if (subquery) {
-            const rightType = walkSubquery(context, subquery);
-            return rightType;
-        }
-        const exprList = predicateOperations.exprList();
-        if (exprList) {
-            const rightType = walkExprList(context, exprList);
-            return rightType;
-        }
-    }
-    if (predicateOperations instanceof ts_mysql_parser_1.PredicateExprLikeContext) {
-        const simpleExpr = predicateOperations.simpleExpr()[0];
-        const rightType = walkSimpleExpr(context, simpleExpr);
-        context.constraints.push({
-            expression: simpleExpr.text,
-            type1: parentType,
-            type2: rightType
-        });
-        return rightType;
-    }
-    throw Error("Not expected");
-}
-function walkExprList(context, exprList) {
-    const listType = exprList.expr().map(item => {
-        const exprType = walkExpr(context, item);
-        return exprType;
-    });
-    const type = {
-        kind: 'TypeOperator',
-        types: listType
-    };
-    return type;
-}
-function walkBitExpr(context, bitExpr) {
-    const simpleExpr = bitExpr.simpleExpr();
-    if (simpleExpr) {
-        return walkSimpleExpr(context, simpleExpr);
-    }
-    if (bitExpr.bitExpr().length == 2) {
-        const bitExprType = freshVar(bitExpr.text, 'number');
-        const bitExprLeft = bitExpr.bitExpr()[0];
-        const typeLeftTemp = walkBitExpr(context, bitExprLeft);
-        const typeLeft = typeLeftTemp.kind == 'TypeOperator' ? typeLeftTemp.types[0] : typeLeftTemp;
-        //const newTypeLeft = typeLeft.name == '?'? freshVar('?', 'bigint') : typeLeft;
-        const bitExprRight = bitExpr.bitExpr()[1];
-        const typeRightTemp = walkBitExpr(context, bitExprRight);
-        //In the expression 'id + (value + 2) + ?' the '(value+2)' is treated as a SimpleExprListContext and return a TypeOperator
-        const typeRight = typeRightTemp.kind == 'TypeOperator' ? typeRightTemp.types[0] : typeRightTemp;
-        //const newTypeRight = typeRight.name == '?'? freshVar('?', 'bigint') : typeRight;
-        context.constraints.push({
-            expression: bitExpr.text,
-            type1: typeLeft,
-            type2: typeRight,
-            mostGeneralType: true,
-            coercionType: 'Sum'
-        });
-        context.constraints.push({
-            expression: bitExpr.text,
-            type1: bitExprType,
-            type2: typeLeft,
-            mostGeneralType: true,
-            coercionType: 'Sum'
-        });
-        context.constraints.push({
-            expression: bitExpr.text,
-            type1: bitExprType,
-            type2: typeRight,
-            mostGeneralType: true,
-            coercionType: 'Sum'
-        });
-        return bitExprType;
-    }
-    if (bitExpr.INTERVAL_SYMBOL()) {
-        const bitExpr2 = bitExpr.bitExpr()[0];
-        const leftType = walkBitExpr(context, bitExpr2);
-        const expr = bitExpr.expr(); //expr interval
-        walkExpr(context, expr);
-        context.constraints.push({
-            expression: bitExpr.text,
-            type1: leftType,
-            type2: freshVar('datetime', 'datetime')
-        });
-        return freshVar('datetime', 'datetime');
-    }
-    throw Error('Invalid sql');
-}
-function walkSimpleExpr(context, simpleExpr) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprColumnRefContext) {
-        const fieldName = (0, select_columns_1.splitName)(simpleExpr.text);
-        if (context.havingExpr) {
-            let foundType = null;
-            context.constraints.forEach(p => {
-                if (p.type1.kind == 'TypeVar' && p.aliasConstraint && p.type1.name == simpleExpr.text) {
-                    foundType = p.type1;
-                }
-                if (p.type2.kind == 'TypeVar' && p.aliasConstraint && p.type2.name == simpleExpr.text) {
-                    foundType = p.type2;
-                }
-            });
-            if (foundType) {
-                return foundType;
-            }
-            const type = freshVar(simpleExpr.text, '?');
-            return type;
-        }
-        else {
-            const columnType = (0, select_columns_1.findColumn)(fieldName, context.fromColumns).columnType;
-            const type = freshVar(simpleExpr.text, columnType);
-            return type;
-        }
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprRuntimeFunctionContext) {
-        const runtimeFunctionCall = simpleExpr.runtimeFunctionCall();
-        if (runtimeFunctionCall.NOW_SYMBOL()) {
-            return freshVar(simpleExpr.text, 'datetime');
-        }
-        if (runtimeFunctionCall.CURDATE_SYMBOL()) {
-            return freshVar(simpleExpr.text, 'date');
-        }
-        if (runtimeFunctionCall.CURTIME_SYMBOL()) {
-            return freshVar(simpleExpr.text, 'time');
-        }
-        if (runtimeFunctionCall.REPLACE_SYMBOL()) {
-            const exprList = runtimeFunctionCall.expr();
-            exprList.forEach(expr => {
-                const exprType = walkExpr(context, expr);
-                context.constraints.push({
-                    expression: expr.text,
-                    type1: exprType,
-                    type2: freshVar('varchar', 'varchar')
-                });
-            });
-            return freshVar('varchar', 'varchar');
-        }
-        if (runtimeFunctionCall.YEAR_SYMBOL() || runtimeFunctionCall.MONTH_SYMBOL() || runtimeFunctionCall.DAY_SYMBOL()) {
-            const expr = (_a = runtimeFunctionCall.exprWithParentheses()) === null || _a === void 0 ? void 0 : _a.expr();
-            if (expr) {
-                const paramType = walkExpr(context, expr);
-                if (paramType.kind == 'TypeVar' && isDateTimeLiteral(paramType.name)) {
-                    paramType.type = 'datetime';
-                }
-                if (paramType.kind == 'TypeVar' && isDateLiteral(paramType.name)) {
-                    paramType.type = 'date';
-                }
-                context.constraints.push({
-                    expression: expr.text,
-                    type1: paramType,
-                    type2: freshVar(simpleExpr.text, 'date')
-                });
-            }
-            const returnType = runtimeFunctionCall.YEAR_SYMBOL() ? 'year' : 'tinyint';
-            return freshVar(simpleExpr.text, returnType);
-        }
-        if (runtimeFunctionCall.HOUR_SYMBOL() || runtimeFunctionCall.MINUTE_SYMBOL() || runtimeFunctionCall.SECOND_SYMBOL()) {
-            const expr = (_b = runtimeFunctionCall.exprWithParentheses()) === null || _b === void 0 ? void 0 : _b.expr();
-            if (expr) {
-                const paramType = walkExpr(context, expr);
-                if (paramType.kind == 'TypeVar' && isTimeLiteral(paramType.name)) {
-                    paramType.type = 'time';
-                }
-                if (paramType.kind == 'TypeVar' && isDateLiteral(paramType.name)) {
-                    paramType.type = 'date';
-                }
-                if (paramType.kind == 'TypeVar' && isDateTimeLiteral(paramType.name)) {
-                    paramType.type = 'datetime';
-                }
-                context.constraints.push({
-                    expression: expr.text,
-                    type1: paramType,
-                    type2: freshVar(simpleExpr.text, 'time')
-                });
-            }
-            //HOUR can return values greater than 23. Ex.: SELECT HOUR('272:59:59');
-            //https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_hour
-            const returnType = runtimeFunctionCall.HOUR_SYMBOL() ? 'int' : 'tinyint';
-            return freshVar(simpleExpr.text, returnType);
-        }
-        const trimFunction = runtimeFunctionCall.trimFunction();
-        if (trimFunction) {
-            const exprList = trimFunction.expr();
-            if (exprList.length == 1) {
-                const exprType = walkExpr(context, exprList[0]);
-                context.constraints.push({
-                    expression: exprList[0].text,
-                    type1: exprType,
-                    type2: freshVar('varchar', 'varchar')
-                });
-            }
-            if (exprList.length == 2) {
-                const exprType = walkExpr(context, exprList[0]);
-                const expr2Type = walkExpr(context, exprList[1]);
-                context.constraints.push({
-                    expression: exprList[0].text,
-                    type1: exprType,
-                    type2: freshVar('varchar', 'varchar')
-                });
-                context.constraints.push({
-                    expression: exprList[1].text,
-                    type1: expr2Type,
-                    type2: freshVar('varchar', 'varchar')
-                });
-            }
-            return freshVar('varchar', 'varchar');
-        }
-        const substringFunction = runtimeFunctionCall.substringFunction();
-        if (substringFunction) {
-            const exprList = substringFunction.expr();
-            const varcharParam = freshVar('varchar', 'varchar');
-            const intParam = freshVar('int', 'int');
-            const params = {
-                kind: 'FixedLengthParams',
-                paramsType: [varcharParam, intParam, intParam]
-            };
-            walkExprListParameters(context, exprList, params);
-            return varcharParam;
-        }
-        if (runtimeFunctionCall.ADDDATE_SYMBOL()
-            || runtimeFunctionCall.DATE_ADD_SYMBOL()
-            || runtimeFunctionCall.SUBDATE_SYMBOL()
-            || runtimeFunctionCall.DATE_SUB_SYMBOL()) {
-            //SELECT ADDDATE('2008-01-02', INTERVAL 31 DAY)
-            //SELECT ADDDATE('2008-01-02', 31)
-            const expr1 = runtimeFunctionCall.expr()[0];
-            const expr2 = runtimeFunctionCall.expr()[1];
-            const typeExpr1 = walkExpr(context, expr1);
-            const typeExpr2 = walkExpr(context, expr2);
-            if (typeExpr1.kind == 'TypeVar' && (isDateLiteral(typeExpr1.name) || isDateTimeLiteral(typeExpr1.name))) {
-                typeExpr1.type = 'datetime';
-            }
-            context.constraints.push({
-                expression: expr1.text,
-                type1: typeExpr1,
-                type2: freshVar('datetime', 'datetime')
-            });
-            context.constraints.push({
-                expression: expr2.text,
-                type1: typeExpr2,
-                type2: freshVar('bigint', 'bigint')
-            });
-            return freshVar('datetime', 'datetime');
-        }
-        if (runtimeFunctionCall.COALESCE_SYMBOL()) {
-            const exprList = (_c = runtimeFunctionCall.exprListWithParentheses()) === null || _c === void 0 ? void 0 : _c.exprList().expr();
-            if (exprList) {
-                const paramType = freshVar('?', '?');
-                const params = {
-                    kind: 'VariableLengthParams',
-                    paramType: 'any'
-                };
-                const paramsTypeList = walkExprListParameters(context, exprList, params);
-                paramsTypeList.forEach((typeVar, paramIndex) => {
-                    context.constraints.push({
-                        expression: runtimeFunctionCall.text + '_param' + (paramIndex + 1),
-                        type1: paramType,
-                        type2: typeVar,
-                        mostGeneralType: true,
-                        coercionType: 'Coalesce'
-                    });
-                });
-                return paramType;
-            }
-        }
-        //MOD (number, number): number
-        if (runtimeFunctionCall.MOD_SYMBOL()) {
-            const functionType = freshVar('number', 'number');
-            const exprList = runtimeFunctionCall.expr();
-            const param1 = walkExpr(context, exprList[0]);
-            const param2 = walkExpr(context, exprList[1]);
-            context.constraints.push({
-                expression: simpleExpr.text,
-                type1: freshVar('number', 'number'),
-                type2: param1,
-                mostGeneralType: true
-            });
-            context.constraints.push({
-                expression: simpleExpr.text,
-                type1: freshVar('number', 'number'),
-                type2: param2,
-                mostGeneralType: true
-            });
-            context.constraints.push({
-                expression: simpleExpr.text,
-                type1: functionType,
-                type2: param1,
-                mostGeneralType: true
-            });
-            context.constraints.push({
-                expression: simpleExpr.text,
-                type1: functionType,
-                type2: param2,
-                mostGeneralType: true
-            });
-            return functionType;
-        }
-        if (runtimeFunctionCall.IF_SYMBOL()) {
-            const exprList = runtimeFunctionCall.expr();
-            const expr1 = exprList[0];
-            const expr2 = exprList[1];
-            const expr3 = exprList[2];
-            walkExpr(context, expr1);
-            const expr2Type = walkExpr(context, expr2);
-            const expr3Type = walkExpr(context, expr3);
-            context.constraints.push({
-                expression: runtimeFunctionCall.text,
-                type1: expr2Type,
-                type2: expr3Type,
-                mostGeneralType: true
-            });
-            return expr2Type;
-        }
-        throw Error('Function not supported: ' + runtimeFunctionCall.text);
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprFunctionContext) {
-        const functionIdentifier = getFunctionName(simpleExpr);
-        if (functionIdentifier === 'concat_ws' || (functionIdentifier === null || functionIdentifier === void 0 ? void 0 : functionIdentifier.toLowerCase()) === 'concat') {
-            const varcharType = freshVar(simpleExpr.text, 'varchar');
-            const params = {
-                kind: 'VariableLengthParams',
-                paramType: '?'
-            };
-            walkFunctionParameters(context, simpleExpr, params);
-            return varcharType;
-        }
-        if (functionIdentifier === 'avg') {
-            const functionType = freshVar(simpleExpr.text, '?');
-            context.constraints.push({
-                expression: simpleExpr.text,
-                type1: functionType,
-                type2: freshVar('decimal', 'decimal'),
-                mostGeneralType: true
-            });
-            const params = {
-                kind: 'FixedLengthParams',
-                paramsType: [functionType]
-            };
-            walkFunctionParameters(context, simpleExpr, params);
-            return functionType;
-        }
-        if (functionIdentifier === 'round') {
-            const functionType = freshVar(simpleExpr.text, '?');
-            const params = {
-                kind: 'FixedLengthParams',
-                paramsType: [functionType]
-            };
-            const paramsType = walkFunctionParameters(context, simpleExpr, params);
-            //The return value has the same type as the first argument
-            context.constraints.push({
-                expression: simpleExpr.text,
-                type1: functionType,
-                type2: paramsType[0],
-                mostGeneralType: true
-            });
-            return functionType;
-        }
-        if (functionIdentifier === 'floor') {
-            const doubleParam = freshVar('double', 'double');
-            const params = {
-                kind: 'FixedLengthParams',
-                paramsType: [doubleParam, doubleParam]
-            };
-            walkFunctionParameters(context, simpleExpr, params);
-            return freshVar(simpleExpr.text, 'bigint');
-        }
-        if (functionIdentifier === 'str_to_date') {
-            const varcharParam = freshVar('varchar', 'varchar');
-            const params = {
-                kind: 'FixedLengthParams',
-                paramsType: [varcharParam, varcharParam]
-            };
-            walkFunctionParameters(context, simpleExpr, params);
-            return freshVar(simpleExpr.text, 'date');
-        }
-        if (functionIdentifier === 'datediff') {
-            const udfExprList = (_d = simpleExpr.functionCall().udfExprList()) === null || _d === void 0 ? void 0 : _d.udfExpr();
-            if (udfExprList) {
-                udfExprList.forEach((inExpr) => {
-                    const expr = inExpr.expr();
-                    const exprType = walkExpr(context, expr);
-                    const newType = verifyDateTypesCoercion(exprType);
-                    context.constraints.push({
-                        expression: expr.text,
-                        type1: newType,
-                        type2: freshVar('date', 'date'),
-                        mostGeneralType: true
-                    });
-                });
-            }
-            return freshVar(simpleExpr.text, 'bigint');
-        }
-        if (functionIdentifier === 'lpad' || functionIdentifier == 'rpad') {
-            const varcharParam = freshVar('varchar', 'varchar');
-            const intParam = freshVar('int', 'int');
-            const params = {
-                kind: 'FixedLengthParams',
-                paramsType: [varcharParam, intParam, varcharParam]
-            };
-            walkFunctionParameters(context, simpleExpr, params);
-            return varcharParam;
-        }
-        if (functionIdentifier === 'lower'
-            || functionIdentifier === 'lcase'
-            || functionIdentifier === 'upper'
-            || functionIdentifier === 'ucase'
-            || functionIdentifier === 'ltrim'
-            || functionIdentifier === 'rtrim') {
-            const varcharParam = freshVar('varchar', 'varchar');
-            const params = {
-                kind: 'FixedLengthParams',
-                paramsType: [varcharParam]
-            };
-            walkFunctionParameters(context, simpleExpr, params);
-            return varcharParam;
-        }
-        if (functionIdentifier === 'length' || functionIdentifier == 'char_length') {
-            const varcharParam = freshVar('varchar', 'varchar');
-            const params = {
-                kind: 'FixedLengthParams',
-                paramsType: [varcharParam]
-            };
-            walkFunctionParameters(context, simpleExpr, params);
-            return freshVar('int', 'int');
-        }
-        if (functionIdentifier === 'abs') {
-            const functionType = freshVar('number', 'number');
-            const udfExprList = (_e = simpleExpr.functionCall().udfExprList()) === null || _e === void 0 ? void 0 : _e.udfExpr();
-            udfExprList === null || udfExprList === void 0 ? void 0 : udfExprList.forEach(expr => {
-                const param1 = walkExpr(context, expr.expr());
-                context.constraints.push({
-                    expression: simpleExpr.text,
-                    type1: functionType,
-                    type2: param1,
-                    mostGeneralType: true
-                });
-            });
-            return functionType;
-        }
-        if (functionIdentifier == 'ceiling' || functionIdentifier == 'ceil') {
-            const functionType = freshVar('number', 'number');
-            const udfExprList = (_f = simpleExpr.functionCall().udfExprList()) === null || _f === void 0 ? void 0 : _f.udfExpr();
-            udfExprList === null || udfExprList === void 0 ? void 0 : udfExprList.forEach(expr => {
-                const param1 = walkExpr(context, expr.expr());
-                context.constraints.push({
-                    expression: simpleExpr.text,
-                    type1: functionType,
-                    type2: param1,
-                    mostGeneralType: true,
-                    coercionType: 'Ceiling'
-                });
-            });
-            return functionType;
-        }
-        if (functionIdentifier == 'timestampdiff') {
-            const udfExprList = (_g = simpleExpr.functionCall().udfExprList()) === null || _g === void 0 ? void 0 : _g.udfExpr();
-            if (udfExprList) {
-                const [first, ...rest] = udfExprList;
-                const unit = first.text.trim().toLowerCase();
-                rest.forEach((inExpr, paramIndex) => {
-                    const expr = inExpr.expr();
-                    const exprType = walkExpr(context, expr);
-                    const newType = verifyDateTypesCoercion(exprType);
-                    //const expectedType = ['hour', 'minute', 'second'].includes(unit)? 'time' : 'datetime'
-                    context.constraints.push({
-                        expression: expr.text,
-                        type1: newType,
-                        type2: freshVar('datetime', 'datetime'),
-                        mostGeneralType: true
-                    });
-                });
-            }
-            return freshVar('int', 'int');
-        }
-        if (functionIdentifier == 'ifnull' || functionIdentifier == 'nullif') {
-            const functionType = freshVar(simpleExpr.text, '?');
-            const udfExprList = (_h = simpleExpr.functionCall().udfExprList()) === null || _h === void 0 ? void 0 : _h.udfExpr();
-            if (udfExprList) {
-                const [expr1, expr2] = udfExprList;
-                const expr1Type = walkExpr(context, expr1.expr());
-                context.constraints.push({
-                    expression: expr1.text,
-                    type1: functionType,
-                    type2: expr1Type
-                });
-                const expr2Type = walkExpr(context, expr2.expr());
-                context.constraints.push({
-                    expression: expr2.text,
-                    type1: functionType,
-                    type2: expr2Type
-                });
-            }
-            return functionType;
-        }
-        if (functionIdentifier == 'md5'
-            || functionIdentifier == 'hex'
-            || functionIdentifier == 'unhex') {
-            const functionType = freshVar(simpleExpr.text, 'char');
-            const udfExprList = (_j = simpleExpr.functionCall().udfExprList()) === null || _j === void 0 ? void 0 : _j.udfExpr();
-            if (udfExprList) {
-                const [expr1] = udfExprList;
-                walkExpr(context, expr1.expr());
-            }
-            return functionType;
-        }
-        throw Error('Function not supported: ' + functionIdentifier);
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprParamMarkerContext) {
-        const param = freshVar('?', '?');
-        context.parameters.push(param);
-        return param;
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprSumContext) {
-        const sumExpr = simpleExpr.sumExpr();
-        if (sumExpr.MAX_SYMBOL() || sumExpr.MIN_SYMBOL()) {
-            const functionType = freshVar(simpleExpr.text, '?');
-            const inSumExpr = (_k = sumExpr.inSumExpr()) === null || _k === void 0 ? void 0 : _k.expr();
-            if (inSumExpr) {
-                const inSumExprType = walkExpr(context, inSumExpr);
-                context.constraints.push({
-                    expression: simpleExpr.text,
-                    type1: functionType,
-                    type2: inSumExprType,
-                    mostGeneralType: true
-                });
-            }
-            return functionType;
-        }
-        if (sumExpr.COUNT_SYMBOL()) {
-            const functionType = freshVar(simpleExpr.text, 'bigint');
-            const inSumExpr = (_l = sumExpr.inSumExpr()) === null || _l === void 0 ? void 0 : _l.expr();
-            if (inSumExpr) {
-                walkExpr(context, inSumExpr);
-            }
-            return functionType;
-        }
-        if (sumExpr.SUM_SYMBOL() || sumExpr.AVG_SYMBOL()) {
-            const functionType = freshVar(simpleExpr.text, '?');
-            const inSumExpr = (_m = sumExpr.inSumExpr()) === null || _m === void 0 ? void 0 : _m.expr();
-            if (inSumExpr) {
-                const inSumExprType = walkExpr(context, inSumExpr);
-                context.constraints.push({
-                    expression: simpleExpr.text,
-                    type1: functionType,
-                    type2: inSumExprType,
-                    mostGeneralType: true,
-                    coercionType: 'SumFunction'
-                });
-            }
-            return functionType;
-        }
-        if (sumExpr.GROUP_CONCAT_SYMBOL()) {
-            const exprList = sumExpr.exprList();
-            if (exprList) {
-                exprList.expr().map(item => {
-                    const exprType = walkExpr(context, item);
-                    return exprType;
-                });
-                /*
-                The result type is TEXT or BLOB unless group_concat_max_len is less than or equal to 512,
-                in which case the result type is VARCHAR or VARBINARY.
-                */
-                //TODO - Infer TEXT/BLOB or VARCHAR/VARBINARY
-                return freshVar(sumExpr.text, 'varchar');
-                ;
-            }
-        }
-        throw Error('Expression not supported: ' + sumExpr.text);
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprLiteralContext) {
-        const literal = simpleExpr.literal();
-        if (literal.textLiteral()) {
-            const text = ((_o = literal.textLiteral()) === null || _o === void 0 ? void 0 : _o.text.slice(1, -1)) || ''; //remove quotes
-            return freshVar(text, 'varchar');
-        }
-        const numLiteral = literal.numLiteral();
-        if (numLiteral) {
-            return freshVar(numLiteral.text, 'bigint');
-            // addNamedNode(simpleExpr, freshVar('bigint', 'bigint'), namedNodes)
-            // if(numLiteral.INT_NUMBER()) {
-            //     const typeInt = freshVar('int', 'int');
-            //     addNamedNode(simpleExpr, typeInt, namedNodes)
-            // }
-            // if(numLiteral.DECIMAL_NUMBER()) {
-            //     const typeDecimal = freshVar('decimal', 'decimal');
-            //     addNamedNode(simpleExpr, typeDecimal, namedNodes)
-            // }
-            // if(numLiteral.FLOAT_NUMBER()) {
-            //     const typeFloat = freshVar('float', 'float');
-            //     addNamedNode(simpleExpr, typeFloat, namedNodes)
-            // }
-            ;
-        }
-        const boolLiteral = literal.boolLiteral();
-        if (boolLiteral) {
-            return freshVar(boolLiteral.text, 'bit');
-        }
-        const nullLiteral = literal.nullLiteral();
-        if (nullLiteral) {
-            return freshVar(nullLiteral.text, '?');
-        }
-        throw Error('literal not supported:' + literal.text);
-        //...
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprListContext) {
-        const exprList = simpleExpr.exprList();
-        const listType = exprList.expr().map(item => {
-            const exprType = walkExpr(context, item);
-            return exprType;
-        });
-        const resultType = {
-            kind: 'TypeOperator',
-            types: listType
-        };
-        return resultType;
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprSubQueryContext) {
-        const subquery = simpleExpr.subquery();
-        const subqueryType = walkSubquery(context, subquery);
-        return subqueryType;
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprCaseContext) {
-        //case when expr then expr else expr
-        const caseType = freshVar(simpleExpr.text, '?');
-        simpleExpr.whenExpression().forEach(whenExprCont => {
-            const whenExpr = whenExprCont.expr();
-            const whenType = walkExpr(context, whenExpr);
-            context.constraints.push({
-                expression: whenExpr.text,
-                type1: whenType.kind == 'TypeOperator' ? whenType.types[0] : whenType,
-                type2: freshVar('tinyint', 'tinyint') //bool
-            });
-        });
-        const thenTypes = simpleExpr.thenExpression().map(thenExprCtx => {
-            const thenExpr = thenExprCtx.expr();
-            const thenType = walkExpr(context, thenExpr);
-            context.constraints.push({
-                expression: thenExprCtx.text,
-                type1: caseType,
-                type2: thenType.kind == 'TypeOperator' ? thenType.types[0] : thenType,
-                mostGeneralType: true,
-            });
-            return thenType;
-        });
-        const elseExpr = (_p = simpleExpr.elseExpression()) === null || _p === void 0 ? void 0 : _p.expr();
-        if (elseExpr) {
-            const elseType = walkExpr(context, elseExpr);
-            context.constraints.push({
-                expression: (_q = simpleExpr.elseExpression()) === null || _q === void 0 ? void 0 : _q.text,
-                type1: caseType,
-                type2: elseType.kind == 'TypeOperator' ? elseType.types[0] : elseType,
-                mostGeneralType: true
-            });
-            thenTypes.forEach(thenType => {
-                var _a;
-                context.constraints.push({
-                    expression: (_a = simpleExpr.elseExpression()) === null || _a === void 0 ? void 0 : _a.text,
-                    type1: thenType,
-                    type2: elseType.kind == 'TypeOperator' ? elseType.types[0] : elseType,
-                    mostGeneralType: true
-                });
-            });
-        }
-        return caseType;
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprIntervalContext) {
-        const exprList = simpleExpr.expr();
-        const exprLeft = exprList[0];
-        const exprRight = exprList[1];
-        const typeLeft = walkExpr(context, exprLeft);
-        const typeRight = walkExpr(context, exprRight);
-        context.constraints.push({
-            expression: exprLeft.text,
-            type1: typeLeft,
-            type2: freshVar('bigint', 'bigint')
-        });
-        if (typeRight.kind == 'TypeVar' && (isDateLiteral(typeRight.name) || isDateTimeLiteral(typeRight.name))) {
-            typeRight.type = 'datetime';
-        }
-        context.constraints.push({
-            expression: exprRight.text,
-            type1: typeRight,
-            type2: freshVar('datetime', 'datetime')
-        });
-        return freshVar('datetime', 'datetime');
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprWindowingFunctionContext) {
-        const windowFunctionCall = simpleExpr.windowFunctionCall();
-        return walkWindowFunctionCall(windowFunctionCall, context);
-    }
-    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprCastContext) {
-        const castType = simpleExpr.castType();
-        if (castType.CHAR_SYMBOL()) {
-            return freshVar(castType.text, 'char');
-        }
-    }
-    throw Error('Invalid expression: ' + simpleExpr.text);
-}
-function walkWindowFunctionCall(windowFunctionCall, context) {
-    if (windowFunctionCall.ROW_NUMBER_SYMBOL()
-        || windowFunctionCall.RANK_SYMBOL()
-        || windowFunctionCall.DENSE_RANK_SYMBOL()
-        || windowFunctionCall.CUME_DIST_SYMBOL()
-        || windowFunctionCall.PERCENT_RANK_SYMBOL()) {
-        return freshVar(windowFunctionCall.text, 'bigint');
-    }
-    const expr = windowFunctionCall.expr();
-    if (expr) {
-        return walkExpr(context, expr);
-    }
-    const exprWithParentheses = windowFunctionCall.exprWithParentheses();
-    if (exprWithParentheses) {
-        const expr = exprWithParentheses.expr();
-        return walkExpr(context, expr);
-    }
-    throw Error('No support for expression' + windowFunctionCall.text);
-}
+exports.getVarType = getVarType;
 function verifyDateTypesCoercion(type) {
     if (type.kind == 'TypeVar' && isDateTimeLiteral(type.name)) {
         type.type = 'datetime';
@@ -1785,91 +123,23 @@ function verifyDateTypesCoercion(type) {
     }
     return type;
 }
+exports.verifyDateTypesCoercion = verifyDateTypesCoercion;
 function isTimeLiteral(literal) {
     return (0, moment_1.default)(literal, 'HH:mm:ss', true).isValid() || (0, moment_1.default)(literal, 'HH:mm', true).isValid();
 }
+exports.isTimeLiteral = isTimeLiteral;
 function isDateTimeLiteral(literal) {
     return (0, moment_1.default)(literal, 'YYYY-MM-DD HH:mm:ss', true).isValid();
 }
+exports.isDateTimeLiteral = isDateTimeLiteral;
 function isDateLiteral(literal) {
     return (0, moment_1.default)(literal, "YYYY-MM-DD", true).isValid();
 }
+exports.isDateLiteral = isDateLiteral;
 function getFunctionName(simpleExprFunction) {
     var _a, _b;
     return ((_a = simpleExprFunction.functionCall().pureIdentifier()) === null || _a === void 0 ? void 0 : _a.text.toLowerCase())
         || ((_b = simpleExprFunction.functionCall().qualifiedIdentifier()) === null || _b === void 0 ? void 0 : _b.text.toLowerCase());
 }
-function walkExprListParameters(context, exprList, params) {
-    return exprList.map((expr, paramIndex) => {
-        const exprType = walkExpr(context, expr);
-        const paramType = params.kind == 'FixedLengthParams' ? params.paramsType[paramIndex] : freshVar(params.paramType, params.paramType);
-        context.constraints.push({
-            expression: expr.text,
-            type1: exprType,
-            type2: paramType,
-            mostGeneralType: true
-        });
-        return paramType;
-    });
-}
-function walkFunctionParameters(context, simpleExprFunction, params) {
-    var _a, _b;
-    const functionName = getFunctionName(simpleExprFunction);
-    const udfExprList = (_a = simpleExprFunction.functionCall().udfExprList()) === null || _a === void 0 ? void 0 : _a.udfExpr();
-    if (udfExprList) {
-        const paramTypes = udfExprList
-            .filter((undefined, paramIndex) => {
-            return functionName == 'timestampdiff' ? paramIndex != 0 : true; //filter the first parameter of timestampdiff function
-        })
-            .map((inExpr, paramIndex) => {
-            const expr = inExpr.expr();
-            const exprType = walkExpr(context, expr);
-            context.constraints.push({
-                expression: expr.text,
-                type1: exprType,
-                type2: params.kind == 'FixedLengthParams' ? params.paramsType[paramIndex] : freshVar(params.paramType, params.paramType),
-                mostGeneralType: true
-            });
-            return exprType;
-        });
-        return paramTypes;
-    }
-    const exprList = (_b = simpleExprFunction.functionCall().exprList()) === null || _b === void 0 ? void 0 : _b.expr();
-    if (exprList) {
-        const paramTypes = exprList.map((inExpr, paramIndex) => {
-            const inSumExprType = walkExpr(context, inExpr);
-            context.constraints.push({
-                expression: inExpr.text,
-                type1: params.kind == 'FixedLengthParams' ? params.paramsType[paramIndex] : freshVar(params.paramType, params.paramType),
-                type2: inSumExprType,
-                mostGeneralType: true
-            });
-            return inSumExprType;
-        });
-        return paramTypes;
-    }
-    throw Error('Error in walkFunctionParameters');
-}
-function walkSubquery(context, queryExpressionParens) {
-    const querySpec = (0, parse_1.getQuerySpecificationsFromSelectStatement)(queryExpressionParens);
-    const subqueryColumns = (0, select_columns_1.getColumnsFrom)(querySpec[0], context.dbSchema, context.withSchema);
-    const newContext = Object.assign(Object.assign({}, context), { fromColumns: context.fromColumns.concat(subqueryColumns) });
-    const typeInferResult = walkQuerySpecification(newContext, querySpec[0]);
-    for (let queryIndex = 1; queryIndex < querySpec.length; queryIndex++) { //union (if have any)
-        const unionColumns = (0, select_columns_1.getColumnsFrom)(querySpec[queryIndex], context.dbSchema, context.withSchema);
-        const unionNewContext = Object.assign(Object.assign({}, context), { fromColumns: context.fromColumns.concat(unionColumns) });
-        const unionResult = walkQuerySpecification(unionNewContext, querySpec[queryIndex]);
-        typeInferResult.types.forEach((field, fieldIndex) => {
-            context.constraints.push({
-                expression: querySpec[queryIndex].text,
-                type1: typeInferResult.types[fieldIndex],
-                type2: unionResult.types[fieldIndex],
-                mostGeneralType: true
-            });
-        });
-    }
-    //Should retrun the union result type, not the first query from result
-    return typeInferResult;
-}
-exports.walkSubquery = walkSubquery;
+exports.getFunctionName = getFunctionName;
 //# sourceMappingURL=collect-constraints.js.map