typesql-cli 0.5.18 → 0.6.2

package/mysql-query-analyzer/traverse.js

@@ -0,0 +1,1613 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyMultipleResult2 = exports.isMultipleRowResult = exports.selectAllColumns = exports.filterColumns = exports.traverseWithClause = exports.traverseQuerySpecification = exports.getUpdateColumns = exports.traverseDeleteStatement = exports.traverseInsertStatement = exports.traverseQueryContext = void 0;
+const ts_mysql_parser_1 = require("ts-mysql-parser");
+const describe_query_1 = require("../describe-query");
+const parse_1 = require("./parse");
+const collect_constraints_1 = require("./collect-constraints");
+const select_columns_1 = require("./select-columns");
+const infer_column_nullability_1 = require("./infer-column-nullability");
+const infer_param_nullability_1 = require("./infer-param-nullability");
+const util_1 = require("./util");
+function traverseQueryContext(queryContext, dbSchema, namedParameters) {
+    var _a, _b, _c, _d;
+    const constraints = [];
+    const parameters = [];
+    const selectStatement = (_a = queryContext.simpleStatement()) === null || _a === void 0 ? void 0 : _a.selectStatement();
+    if (selectStatement) {
+        const typeInfer = traverseSelectStatement(selectStatement, constraints, parameters, dbSchema, namedParameters);
+        return typeInfer;
+    }
+    const insertStatement = (_b = queryContext.simpleStatement()) === null || _b === void 0 ? void 0 : _b.insertStatement();
+    if (insertStatement) {
+        return traverseInsertStatement(insertStatement, constraints, parameters, dbSchema);
+    }
+    const updateStatement = (_c = queryContext.simpleStatement()) === null || _c === void 0 ? void 0 : _c.updateStatement();
+    if (updateStatement) {
+        const typeInfer = traverseUpdateStatement(updateStatement, constraints, parameters, dbSchema, namedParameters);
+        return typeInfer;
+    }
+    const deleteStatement = (_d = queryContext.simpleStatement()) === null || _d === void 0 ? void 0 : _d.deleteStatement();
+    if (deleteStatement) {
+        const typeInfer = traverseDeleteStatement(deleteStatement, constraints, parameters, dbSchema);
+        return typeInfer;
+    }
+    throw Error('traverseSql - not supported: ' + queryContext.constructor.name);
+}
+exports.traverseQueryContext = traverseQueryContext;
+function traverseSelectStatement(selectStatement, constraints, parameters, dbSchema, namedParameters) {
+    const queryExpression = selectStatement.queryExpression();
+    if (queryExpression) {
+        const withClause = queryExpression.withClause();
+        const withSchema = [];
+        if (withClause) {
+            traverseWithClause(withClause, constraints, parameters, dbSchema, withSchema);
+        }
+        const queryExpressionBody = queryExpression.queryExpressionBody();
+        if (queryExpressionBody) {
+            const result = traverseQueryExpressionBody(queryExpressionBody, constraints, parameters, dbSchema, withSchema, []);
+            const orderByParameters = (0, parse_1.extractOrderByParameters)(selectStatement);
+            const limitParameters = (0, parse_1.extractLimitParameters)(selectStatement);
+            const paramInference = (0, infer_param_nullability_1.inferParamNullabilityQueryExpression)(queryExpression);
+            const allParameters = parameters
+                .map((param, index) => {
+                const param2 = {
+                    name: param.name,
+                    type: param,
+                    notNull: paramInference[index],
+                    table: ''
+                };
+                return param2;
+            });
+            const paramIndexes = (0, util_1.getParameterIndexes)(namedParameters.slice(0, allParameters.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) => {
+                    constraints.push({
+                        expression: paramIndex.paramName,
+                        type1: allParameters[cur].type,
+                        type2: allParameters[next].type
+                    });
+                });
+            });
+            const isMultiRow = isMultipleRowResult(selectStatement, result.fromColumns);
+            const traverseResult = {
+                type: 'Select',
+                constraints,
+                columns: result.columns,
+                parameters: allParameters,
+                limitParameters,
+                isMultiRow
+            };
+            const orderByColumns = orderByParameters.length > 0 ? getOrderByColumns(result.fromColumns, result.columns) : undefined;
+            if (orderByColumns) {
+                traverseResult.orderByColumns = orderByColumns;
+            }
+            return traverseResult;
+        }
+    }
+    throw Error('traverseSelectStatement - not supported: ' + selectStatement.text);
+}
+function traverseInsertStatement(insertStatement, constraints, parameters, dbSchema) {
+    var _a, _b;
+    const allParameters = [];
+    const paramsNullability = {};
+    let exprOrDefaultList = [];
+    const valuesContext = (_a = insertStatement.insertFromConstructor()) === null || _a === void 0 ? void 0 : _a.insertValues().valueList().values();
+    if (valuesContext) {
+        exprOrDefaultList = valuesContext.map(valueContext => { var _a; return ((_a = valueContext.children) === null || _a === void 0 ? void 0 : _a.filter(valueContext => valueContext instanceof ts_mysql_parser_1.ExprIsContext || valueContext.text == 'DEFAULT')) || []; });
+    }
+    const insertIntoTable = (0, collect_constraints_1.getInsertIntoTable)(insertStatement);
+    const fromColumns = dbSchema
+        .filter(c => c.table == insertIntoTable)
+        .map(c => {
+        const col = {
+            table: c.table,
+            columnName: c.column,
+            columnType: (0, collect_constraints_1.freshVar)(c.column, c.column_type),
+            columnKey: c.columnKey,
+            notNull: c.notNull
+        };
+        return col;
+    });
+    const insertColumns = (0, collect_constraints_1.getInsertColumns)(insertStatement, fromColumns);
+    exprOrDefaultList.forEach(exprOrDefault => {
+        exprOrDefault.forEach((expr, index) => {
+            const column = insertColumns[index];
+            if (expr instanceof ts_mysql_parser_1.ExprContext) {
+                const numberParamsBefore = parameters.length;
+                const exprType = traverseExpr(expr, constraints, parameters, dbSchema, [], fromColumns);
+                const paramNullabilityExpr = (0, infer_param_nullability_1.inferParamNullability)(expr);
+                parameters.slice(numberParamsBefore).forEach(param => {
+                    paramsNullability[param.id] = paramNullabilityExpr.every(n => n) && column.notNull;
+                });
+                constraints.push({
+                    expression: expr.text,
+                    //TODO - CHANGING ORDER SHOULDN'T AFFECT THE TYPE INFERENCE
+                    type1: exprType.kind == 'TypeOperator' ? exprType.types[0] : exprType,
+                    type2: (0, collect_constraints_1.freshVar)(column.columnName, column.columnType.type)
+                });
+            }
+            else {
+            }
+        });
+    });
+    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 = parameters.length;
+            const exprType = traverseExpr(expr, constraints, parameters, dbSchema, /*withSchema*/ [], fromColumns);
+            const column = (0, select_columns_1.findColumn)(field, fromColumns);
+            parameters.slice(numberParamsBefore).forEach(param => {
+                paramsNullability[param.id] = column.notNull;
+            });
+            constraints.push({
+                expression: expr.text,
+                type1: exprType,
+                type2: (0, collect_constraints_1.freshVar)(column.columnName, column.columnType.type)
+            });
+        }
+    });
+    const insertQueryExpression = insertStatement.insertQueryExpression();
+    if (insertQueryExpression) {
+        //TODO - REMOVE numberParamsBefore (walk first insertQueryExpression)
+        const numberParamsBefore = parameters.length;
+        const exprTypes = traverseInsertQueryExpression(insertQueryExpression, constraints, parameters, dbSchema, /*withSchema*/ [], fromColumns);
+        exprTypes.columns.forEach((type, index) => {
+            const column = insertColumns[index];
+            if (type.type.kind == 'TypeVar') {
+                paramsNullability[type.type.id] = column.notNull;
+            }
+            constraints.push({
+                expression: insertQueryExpression.text,
+                type1: type.type,
+                type2: (0, collect_constraints_1.freshVar)(column.columnName, column.columnType.type)
+            });
+        });
+        const paramNullabilityExpr = (0, infer_param_nullability_1.inferParamNullabilityQuery)(insertQueryExpression);
+        parameters.slice(numberParamsBefore).forEach((param, index) => {
+            if (paramsNullability[param.id] == null) {
+                paramsNullability[param.id] = paramNullabilityExpr[index];
+            }
+        });
+    }
+    const typeInfo = (0, collect_constraints_1.generateTypeInfo)(parameters, constraints);
+    typeInfo.forEach((param, index) => {
+        const paramId = parameters[index].id;
+        allParameters.push({
+            name: 'param' + (allParameters.length + 1),
+            columnType: (0, describe_query_1.verifyNotInferred)(param),
+            notNull: paramsNullability[paramId]
+        });
+    });
+    const typeInferenceResult = {
+        type: 'Insert',
+        constraints: constraints,
+        parameters: allParameters
+    };
+    return typeInferenceResult;
+}
+exports.traverseInsertStatement = traverseInsertStatement;
+function traverseUpdateStatement(updateStatement, constraints, parameters, dbSchema, namedParamters) {
+    var _a;
+    const updateElement = updateStatement.updateList().updateElement();
+    const withClause = updateStatement.withClause();
+    const withSchema = [];
+    if (withClause) {
+        traverseWithClause(withClause, constraints, parameters, dbSchema, withSchema);
+    }
+    const updateColumns = getUpdateColumns(updateStatement, constraints, parameters, dbSchema, withSchema, []);
+    const dataTypes = [];
+    const whereParameters = [];
+    const paramsBefore = parameters.length;
+    const whereExpr = (_a = updateStatement.whereClause()) === null || _a === void 0 ? void 0 : _a.expr();
+    const paramNullability = (0, infer_param_nullability_1.inferParamNullability)(updateStatement);
+    updateElement.forEach(updateElement => {
+        const expr = updateElement.expr();
+        if (expr) {
+            const result = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, updateColumns);
+            const columnName = updateElement.columnRef().text;
+            const field = (0, select_columns_1.splitName)(columnName);
+            const column = (0, select_columns_1.findColumn)(field, updateColumns);
+            constraints.push({
+                expression: updateStatement.text,
+                type1: result,
+                type2: column.columnType //freshVar(column.columnName, )
+            });
+            parameters.slice(paramsBefore, parameters.length).forEach((param, index) => {
+                dataTypes.push({
+                    name: namedParamters[paramsBefore + index] || field.name,
+                    type: param,
+                    notNull: column.notNull && !(0, infer_column_nullability_1.possibleNull)(field, expr),
+                    table: ''
+                });
+            });
+        }
+    });
+    const paramsAfter = parameters.length;
+    if (whereExpr) {
+        traverseExpr(whereExpr, constraints, parameters, dbSchema, withSchema, updateColumns);
+    }
+    parameters.slice(0, paramsBefore).forEach((param, index) => {
+        whereParameters.push({
+            name: namedParamters[index] || 'param' + (whereParameters.length + 1),
+            type: param,
+            notNull: paramNullability[index],
+            table: ''
+        });
+    });
+    parameters.slice(paramsAfter).forEach((param, index) => {
+        whereParameters.push({
+            name: namedParamters[paramsAfter + index] || 'param' + (whereParameters.length + 1),
+            type: param,
+            notNull: paramNullability[paramsAfter + index],
+            table: ''
+        });
+    });
+    const typeInferenceResult = {
+        type: 'Update',
+        constraints,
+        data: dataTypes,
+        parameters: whereParameters
+    };
+    return typeInferenceResult;
+}
+function traverseDeleteStatement(deleteStatement, constraints, parameters, dbSchema) {
+    var _a;
+    const whereExpr = (_a = deleteStatement.whereClause()) === null || _a === void 0 ? void 0 : _a.expr();
+    const deleteColumns = (0, collect_constraints_1.getDeleteColumns)(deleteStatement, dbSchema);
+    const allParameters = [];
+    if (whereExpr) {
+        traverseExpr(whereExpr, constraints, parameters, dbSchema, [], deleteColumns);
+        const typeInfo = (0, collect_constraints_1.generateTypeInfo)(parameters, 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 = {
+        type: 'Delete',
+        constraints,
+        parameters: allParameters
+    };
+    return typeInferenceResult;
+}
+exports.traverseDeleteStatement = traverseDeleteStatement;
+function getUpdateColumns(updateStatement, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    const tableReferences = updateStatement.tableReferenceList().tableReference();
+    const columns = traverseTableReferenceList(tableReferences, constraints, parameters, dbSchema, withSchema, fromColumns);
+    return columns;
+}
+exports.getUpdateColumns = getUpdateColumns;
+function traverseInsertQueryExpression(insertQueryExpression, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    const queryExpressionOrParens = insertQueryExpression.queryExpressionOrParens();
+    return traverseQueryExpressionOrParens(queryExpressionOrParens, constraints, parameters, dbSchema, withSchema, fromColumns);
+}
+function traverseQueryExpressionOrParens(queryExpressionOrParens, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    const queryExpression = queryExpressionOrParens.queryExpression();
+    if (queryExpression) {
+        return traverseQueryExpression(queryExpression, constraints, parameters, dbSchema, withSchema, fromColumns);
+    }
+    const queryEpressionParens = queryExpressionOrParens.queryExpressionParens();
+    if (queryEpressionParens) {
+        return traverseQueryExpressionParens(queryEpressionParens, constraints, parameters, dbSchema, withSchema, fromColumns);
+    }
+    throw Error("walkQueryExpressionOrParens");
+}
+function traverseQueryExpression(queryExpression, constraints, parameters, dbSchema, withSchema, fromColumns, recursive = false) {
+    const queryExpressionBody = queryExpression.queryExpressionBody();
+    if (queryExpressionBody) {
+        return traverseQueryExpressionBody(queryExpressionBody, constraints, parameters, dbSchema, withSchema, fromColumns);
+    }
+    const queryExpressionParens = queryExpression.queryExpressionParens();
+    if (queryExpressionParens) {
+        return traverseQueryExpressionParens(queryExpressionParens, constraints, parameters, dbSchema, withSchema, fromColumns, recursive);
+    }
+    throw Error("walkQueryExpression");
+}
+function traverseQueryExpressionParens(queryExpressionParens, constraints, parameters, dbSchema, withSchema, fromColumns, recursive = false) {
+    const queryExpression = queryExpressionParens.queryExpression();
+    if (queryExpression) {
+        return traverseQueryExpression(queryExpression, constraints, parameters, dbSchema, withSchema, fromColumns, recursive);
+    }
+    const queryExpressionParens2 = queryExpressionParens.queryExpressionParens();
+    if (queryExpressionParens2) {
+        return traverseQueryExpressionParens(queryExpressionParens, constraints, parameters, dbSchema, withSchema, fromColumns, recursive);
+    }
+    throw Error("walkQueryExpressionParens");
+}
+function traverseQueryExpressionBody(queryExpressionBody, constraints, parameters, dbSchema, withSchema, fromColumns, recursiveNames) {
+    const subQuery = queryExpressionBody instanceof ts_mysql_parser_1.SubqueryContext ? true : false;
+    const allQueries = (0, parse_1.getAllQuerySpecificationsFromSelectStatement)(queryExpressionBody);
+    const [first, ...unionQuerySpec] = allQueries;
+    const mainQueryResult = traverseQuerySpecification(first, constraints, parameters, dbSchema, withSchema, fromColumns, subQuery);
+    const resultTypes = mainQueryResult.columns.map((t, index) => unionQuerySpec.length == 0 ? t.type : (0, collect_constraints_1.freshVar)(recursiveNames && recursiveNames.length > 0 ? recursiveNames[index] : t.name, t.type.type)); //TODO mover para traversequeryspecificat?
+    for (let queryIndex = 0; queryIndex < unionQuerySpec.length; queryIndex++) {
+        const columnNames = recursiveNames && recursiveNames.length > 0 ? recursiveNames : mainQueryResult.columns.map(col => col.name);
+        const newFromColumns = recursiveNames ? renameFromColumns(mainQueryResult.columns, columnNames) : mainQueryResult.fromColumns;
+        const unionQuery = unionQuerySpec[queryIndex];
+        const unionResult = traverseQuerySpecification(unionQuery, constraints, parameters, dbSchema, withSchema, newFromColumns, subQuery);
+        resultTypes.forEach((t2, index) => {
+            mainQueryResult.columns[index].notNull = mainQueryResult.columns[index].notNull && unionResult.columns[index].notNull;
+            constraints.push({
+                expression: 'union',
+                coercionType: 'Union',
+                mostGeneralType: true,
+                type1: t2,
+                type2: unionResult.columns[index].type
+            });
+        });
+    }
+    const resultTypeAndNotNull = resultTypes.map((c, index) => {
+        const col = {
+            name: resultTypes[index].name,
+            type: resultTypes[index],
+            notNull: mainQueryResult.columns[index].notNull,
+            table: c.table || ''
+        };
+        return col;
+    });
+    const result = {
+        columns: resultTypeAndNotNull,
+        fromColumns: mainQueryResult.fromColumns
+    };
+    return result;
+}
+function renameFromColumns(fromColumns, recursiveNames) {
+    const newFromColumns = fromColumns.map((col, index) => {
+        const newCol = {
+            table: "",
+            columnName: recursiveNames[index],
+            columnType: col.type,
+            columnKey: "",
+            notNull: col.notNull
+        };
+        return newCol;
+    });
+    return newFromColumns;
+}
+function traverseQuerySpecification(querySpec, constraints, parameters, dbSchema, withSchema, fromColumnsParent, subQuery = false) {
+    const fromClause = querySpec.fromClause();
+    const fromColumns = fromClause ? traverseFromClause(fromClause, constraints, parameters, dbSchema, withSchema, fromColumnsParent) : [];
+    const allColumns = subQuery ? fromColumnsParent.concat(fromColumns) : fromColumns; //(... where id = t1.id)
+    const selectItemListResult = traverseSelectItemList(querySpec.selectItemList(), constraints, parameters, dbSchema, withSchema, allColumns);
+    const whereClause = querySpec.whereClause();
+    //TODO - HAVING, BLAH
+    if (whereClause) {
+        const whereExpr = whereClause === null || whereClause === void 0 ? void 0 : whereClause.expr();
+        traverseExpr(whereExpr, constraints, parameters, dbSchema, withSchema, allColumns);
+    }
+    const columnNullability = (0, infer_column_nullability_1.inferNotNull)(querySpec, dbSchema, allColumns);
+    const columns = selectItemListResult.types.map((t, index) => {
+        const resultType = {
+            name: t.name,
+            type: t,
+            notNull: columnNullability[index],
+            table: t.table || ''
+        };
+        return resultType;
+    });
+    const havingClause = querySpec.havingClause();
+    if (havingClause) {
+        const selectColumns = columns.map(c => {
+            const col = {
+                table: "",
+                columnName: c.name,
+                columnType: c.type,
+                columnKey: "",
+                notNull: c.notNull
+            };
+            return col;
+        });
+        traverseHavingClause(havingClause, constraints, parameters, dbSchema, withSchema, selectColumns.concat(fromColumns));
+    }
+    return {
+        columns,
+        fromColumns
+    };
+}
+exports.traverseQuerySpecification = traverseQuerySpecification;
+function traverseWithClause(withClause, constraints, parameters, dbSchema, withSchema) {
+    //result1, result2
+    withClause.commonTableExpression().forEach(commonTableExpression => {
+        var _a;
+        const identifier = commonTableExpression.identifier().text;
+        const recursiveNames = withClause.RECURSIVE_SYMBOL() ? ((_a = commonTableExpression.columnInternalRefList()) === null || _a === void 0 ? void 0 : _a.columnInternalRef().map(t => t.text)) || [] : undefined;
+        const subQuery = commonTableExpression.subquery();
+        const subqueryResult = traverseSubquery(subQuery, constraints, parameters, dbSchema, withSchema, [], recursiveNames); //recursive= true??
+        subqueryResult.columns.forEach(col => {
+            const withCol = {
+                table: identifier,
+                columnName: col.name,
+                columnType: col.type,
+                columnKey: "",
+                notNull: col.notNull
+            };
+            withSchema.push(withCol);
+        });
+    });
+}
+exports.traverseWithClause = traverseWithClause;
+function traverseFromClause(fromClause, constraints, parameters, dbSchema, withSchema, fromColumnsParent) {
+    var _a;
+    const tableReferenceList = (_a = fromClause.tableReferenceList()) === null || _a === void 0 ? void 0 : _a.tableReference();
+    const fromColumns = tableReferenceList ? traverseTableReferenceList(tableReferenceList, constraints, parameters, dbSchema, withSchema, fromColumnsParent) : [];
+    return fromColumns;
+}
+function traverseTableReferenceList(tableReferenceList, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    const result = [];
+    tableReferenceList.forEach(tab => {
+        const tableFactor = tab.tableFactor();
+        if (tableFactor) {
+            const fields = traverseTableFactor(tableFactor, constraints, parameters, dbSchema, withSchema, fromColumns);
+            result.push(...fields);
+        }
+        const allJoinedColumns = [];
+        let firstLeftJoinIndex = -1;
+        tab.joinedTable().forEach((joined, index) => {
+            var _a, _b;
+            if (((_a = joined.innerJoinType()) === null || _a === void 0 ? void 0 : _a.INNER_SYMBOL()) || ((_b = joined.innerJoinType()) === null || _b === void 0 ? void 0 : _b.JOIN_SYMBOL())) {
+                firstLeftJoinIndex = -1; //dont need to add notNull = false to joins
+            }
+            else if (firstLeftJoinIndex == -1) {
+                firstLeftJoinIndex = index; //add notNull = false to all joins after the first left join
+            }
+            const tableReferences = joined.tableReference();
+            if (tableReferences) {
+                const usingFields = (0, select_columns_1.extractFieldsFromUsingClause)(joined);
+                const joinedFields = traverseTableReferenceList([tableReferences], constraints, parameters, dbSchema, withSchema, fromColumns);
+                //doesn't duplicate the fields of the USING clause. Ex. INNER JOIN mytable2 USING(id);
+                const joinedFieldsFiltered = usingFields.length > 0 ? filterUsingFields(joinedFields, usingFields) : joinedFields;
+                allJoinedColumns.push(joinedFieldsFiltered);
+                const onClause = joined.expr(); //ON expr
+                if (onClause) {
+                    joinedFieldsFiltered.forEach(field => {
+                        const fieldName = {
+                            name: field.columnName,
+                            prefix: field.tableAlias || ''
+                        };
+                        field.notNull = field.notNull || !(0, infer_column_nullability_1.possibleNull)(fieldName, onClause);
+                    });
+                    //apply inference to the parent join too
+                    result.forEach(field => {
+                        const fieldName = {
+                            name: field.columnName,
+                            prefix: field.tableAlias || ''
+                        };
+                        field.notNull = field.notNull || !(0, infer_column_nullability_1.possibleNull)(fieldName, onClause);
+                    });
+                    traverseExpr(onClause, constraints, parameters, dbSchema, withSchema, allJoinedColumns.flatMap(c => c).concat(result));
+                }
+            }
+        });
+        allJoinedColumns.forEach((joinedColumns, index) => {
+            joinedColumns.forEach(field => {
+                if (firstLeftJoinIndex != -1 && index >= firstLeftJoinIndex) {
+                    const newField = Object.assign(Object.assign({}, field), { notNull: false });
+                    result.push(newField);
+                }
+                else {
+                    result.push(field);
+                }
+            });
+        });
+    });
+    return result;
+}
+function traverseTableFactor(tableFactor, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    var _a;
+    const singleTable = tableFactor.singleTable();
+    if (singleTable) {
+        return traverseSingleTable(singleTable, constraints, parameters, dbSchema, withSchema);
+    }
+    const derivadTable = tableFactor.derivedTable();
+    if (derivadTable) {
+        const tableAlias = (_a = derivadTable.tableAlias()) === null || _a === void 0 ? void 0 : _a.identifier().text;
+        const subQuery = derivadTable.subquery();
+        if (subQuery) {
+            const subQueryResult = traverseSubquery(subQuery, constraints, parameters, dbSchema, withSchema, fromColumns);
+            const result = subQueryResult.columns.map(t => {
+                const colDef = {
+                    table: tableAlias || '',
+                    columnName: t.name,
+                    columnType: t.type,
+                    columnKey: "",
+                    notNull: t.notNull,
+                    tableAlias: tableAlias
+                };
+                return colDef;
+            });
+            return result;
+        }
+    }
+    const tableReferenceListParens = tableFactor.tableReferenceListParens();
+    if (tableReferenceListParens) {
+        const listParens = traverseTableReferenceListParens(tableReferenceListParens, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return listParens;
+    }
+    throw Error('traverseTableFactor - not supported: ' + tableFactor.constructor.name);
+}
+//tableReferenceList | tableReferenceListParens
+function traverseTableReferenceListParens(ctx, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    const tableReferenceList = ctx.tableReferenceList();
+    if (tableReferenceList) {
+        return traverseTableReferenceList(tableReferenceList.tableReference(), constraints, parameters, dbSchema, withSchema, fromColumns);
+    }
+    const tableReferenceListParens = ctx.tableReferenceListParens();
+    if (tableReferenceListParens) {
+        return traverseTableReferenceListParens(tableReferenceListParens, constraints, parameters, dbSchema, withSchema, fromColumns);
+    }
+    throw Error('traverseTableReferenceListParens - not supported: ' + ctx.constructor.name);
+}
+function traverseSingleTable(singleTable, constraints, parameters, dbSchema, withSchema) {
+    var _a;
+    const table = singleTable === null || singleTable === void 0 ? void 0 : singleTable.tableRef().text;
+    const tableAlias = (_a = singleTable === null || singleTable === void 0 ? void 0 : singleTable.tableAlias()) === null || _a === void 0 ? void 0 : _a.identifier().text;
+    const tableName = (0, select_columns_1.splitName)(table);
+    const fields = filterColumns(dbSchema, withSchema, tableAlias, tableName);
+    return fields;
+}
+function traverseSubquery(subQuery, constraints, parameters, dbSchema, fromColumns, withSchema, recursiveNames) {
+    const result = traverseQueryExpressionBody(subQuery, constraints, parameters, dbSchema, fromColumns, withSchema, recursiveNames);
+    return result;
+}
+function traverseSelectItemList(selectItemList, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    const listType = [];
+    if (selectItemList.MULT_OPERATOR()) {
+        fromColumns.forEach(col => {
+            const columnType = (0, collect_constraints_1.createColumnType)(col);
+            listType.push(columnType);
+        });
+    }
+    selectItemList.selectItem().forEach(selectItem => {
+        const tableWild = selectItem.tableWild();
+        if (tableWild) {
+            if (tableWild.MULT_OPERATOR()) {
+                const itemName = (0, select_columns_1.splitName)(selectItem.text);
+                const allColumns = selectAllColumns(itemName.prefix, fromColumns);
+                allColumns.forEach(col => {
+                    const columnType = (0, collect_constraints_1.createColumnType)(col);
+                    listType.push(columnType);
+                });
+            }
+        }
+        const expr = selectItem.expr();
+        if (expr) {
+            const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+            if (exprType.kind == 'TypeOperator') {
+                const subqueryType = exprType.types[0];
+                subqueryType.name = (0, select_columns_1.getColumnName)(selectItem);
+                listType.push(subqueryType);
+            }
+            else if (exprType.kind == 'TypeVar') {
+                exprType.name = (0, select_columns_1.getColumnName)(selectItem);
+                listType.push(Object.assign({}, exprType)); //clone
+            }
+        }
+    });
+    const result = {
+        kind: 'TypeOperator',
+        types: listType
+    };
+    return result;
+}
+function traverseHavingClause(havingClause, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    const havingExpr = havingClause.expr();
+    traverseExpr(havingExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+}
+function traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    if (expr instanceof ts_mysql_parser_1.ExprIsContext) {
+        const boolPri = expr.boolPri();
+        const boolPriType = traverseBoolPri(boolPri, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return boolPriType;
+    }
+    if (expr instanceof ts_mysql_parser_1.ExprNotContext) {
+        return (0, collect_constraints_1.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];
+        traverseExpr(exprLeft, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const exprRight = expr.expr()[1];
+        traverseExpr(exprRight, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return (0, collect_constraints_1.freshVar)(expr.text, 'tinyint');
+    }
+    throw Error('traverseExpr - not supported: ' + expr.text);
+}
+function traverseBoolPri(boolPri, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    if (boolPri instanceof ts_mysql_parser_1.PrimaryExprPredicateContext) {
+        const predicate = boolPri.predicate();
+        const predicateType = traversePredicate(predicate, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return predicateType;
+    }
+    if (boolPri instanceof ts_mysql_parser_1.PrimaryExprIsNullContext) {
+        const boolPri2 = boolPri.boolPri();
+        traverseBoolPri(boolPri2, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return (0, collect_constraints_1.freshVar)(boolPri.text, '?');
+    }
+    if (boolPri instanceof ts_mysql_parser_1.PrimaryExprCompareContext) {
+        const compareLeft = boolPri.boolPri();
+        const compareRight = boolPri.predicate();
+        const typeLeft = traverseBoolPri(compareLeft, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const typeRight = traversePredicate(compareRight, constraints, parameters, dbSchema, withSchema, fromColumns);
+        constraints.push({
+            expression: boolPri.text,
+            type1: typeLeft,
+            type2: typeRight
+        });
+        return (0, collect_constraints_1.freshVar)(boolPri.text, 'tinyint');
+    }
+    if (boolPri instanceof ts_mysql_parser_1.PrimaryExprAllAnyContext) {
+        const compareLeft = boolPri.boolPri();
+        const compareRight = boolPri.subquery();
+        const typeLeft = traverseBoolPri(compareLeft, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const subQueryResult = traverseSubquery(compareRight, constraints, parameters, dbSchema, withSchema, fromColumns);
+        constraints.push({
+            expression: boolPri.text,
+            type1: typeLeft,
+            type2: {
+                kind: 'TypeOperator',
+                types: subQueryResult.columns.map(t => t.type)
+            }
+        });
+        return (0, collect_constraints_1.freshVar)(boolPri.text, 'tinyint');
+    }
+    throw Error('traverseExpr - not supported: ' + boolPri.constructor.name);
+}
+function traversePredicate(predicate, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    const bitExpr = predicate.bitExpr()[0]; //TODO - predicate length = 2? [1] == predicateOperations
+    const bitExprType = traverseBitExpr(bitExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+    const predicateOperations = predicate.predicateOperations();
+    if (predicateOperations) {
+        const rightType = traversePredicateOperations(predicateOperations, bitExprType, constraints, parameters, fromColumns, dbSchema, withSchema);
+        if (bitExprType.kind == 'TypeOperator' && rightType.kind == 'TypeOperator') {
+            rightType.types.forEach((t, i) => {
+                constraints.push({
+                    expression: predicateOperations.text,
+                    type1: t,
+                    type2: bitExprType.types[i],
+                    mostGeneralType: true
+                });
+            });
+        }
+        if (bitExprType.kind == 'TypeVar' && rightType.kind == 'TypeOperator') {
+            rightType.types.forEach((t, i) => {
+                constraints.push({
+                    expression: predicateOperations.text,
+                    type1: bitExprType,
+                    type2: Object.assign(Object.assign({}, t), { list: true }),
+                    mostGeneralType: true
+                });
+            });
+            // return rightType.types[0];
+        }
+        return bitExprType;
+    }
+    return bitExprType;
+}
+function traverseExprList(exprList, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    const listType = exprList.expr().map(item => {
+        const exprType = traverseExpr(item, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return exprType;
+    });
+    const type = {
+        kind: 'TypeOperator',
+        types: listType
+    };
+    return type;
+}
+function traverseBitExpr(bitExpr, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    const simpleExpr = bitExpr.simpleExpr();
+    if (simpleExpr) {
+        return traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+    }
+    if (bitExpr.bitExpr().length == 2) {
+        const bitExprLeft = bitExpr.bitExpr()[0];
+        const typeLeftTemp = traverseBitExpr(bitExprLeft, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const typeLeft = typeLeftTemp.kind == 'TypeOperator' ? typeLeftTemp.types[0] : typeLeftTemp;
+        //const newTypeLeft = typeLeft.name == '?'? freshVar('?', 'bigint') : typeLeft;
+        const bitExprRight = bitExpr.bitExpr()[1];
+        const typeRightTemp = traverseBitExpr(bitExprRight, constraints, parameters, dbSchema, withSchema, fromColumns);
+        //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;
+        const bitExprType = (0, collect_constraints_1.freshVar)(bitExpr.text, '?');
+        if (typeLeftTemp.kind == 'TypeVar' && typeRightTemp.kind == 'TypeVar' && typeLeftTemp.table == typeRightTemp.table) {
+            bitExprType.table = typeLeftTemp.table;
+        }
+        //PRECISA?
+        // constraints.push({
+        //     expression: bitExpr.text,
+        //     type1: typeLeft,
+        //     type2: typeRight,
+        //     mostGeneralType: true,
+        //     coercionType: 'Sum'
+        // })
+        // constraints.push({
+        //     expression: bitExpr.text,
+        //     type1: typeLeft,
+        //     type2: typeRight,
+        //     mostGeneralType: true,
+        //     coercionType: 'Sum'
+        // })
+        // constraints.push({
+        //     expression: bitExpr.text,
+        //     type1: bitExprType,
+        //     type2: typeRight,
+        //     mostGeneralType: true,
+        //     coercionType: 'Sum'
+        // })
+        constraints.push({
+            expression: bitExprLeft.text,
+            type1: bitExprType,
+            type2: typeLeft,
+            mostGeneralType: true,
+            coercionType: 'Sum'
+        });
+        constraints.push({
+            expression: bitExprRight.text,
+            type1: bitExprType,
+            type2: typeRight,
+            mostGeneralType: true,
+            coercionType: 'Sum'
+        });
+        // const resultType = freshVar(bitExprRight.text, 'number');
+        // constraints.push({
+        //     expression: bitExprRight.text,
+        //     type1: resultType,
+        //     type2: freshVar(bitExprRight.text, 'number'),
+        //     mostGeneralType: true,
+        //     coercionType: 'Sum'
+        // })
+        return bitExprType;
+    }
+    if (bitExpr.INTERVAL_SYMBOL()) {
+        const bitExpr2 = bitExpr.bitExpr()[0];
+        const leftType = traverseBitExpr(bitExpr2, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const expr = bitExpr.expr(); //expr interval
+        traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+        constraints.push({
+            expression: bitExpr.text,
+            type1: leftType,
+            type2: (0, collect_constraints_1.freshVar)('datetime', 'datetime')
+        });
+        return (0, collect_constraints_1.freshVar)('datetime', 'datetime');
+    }
+    throw Error('traverseBitExpr - not supported: ' + bitExpr.constructor.name);
+}
+function traversePredicateOperations(predicateOperations, parentType, constraints, parameters, fromColumns, dbSchema, withSchema) {
+    if (predicateOperations instanceof ts_mysql_parser_1.PredicateExprInContext) {
+        const subquery = predicateOperations.subquery();
+        if (subquery) {
+            const subQueryResult = traverseSubquery(subquery, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return { kind: 'TypeOperator', types: subQueryResult.columns.map(t => t.type) };
+        }
+        const exprList = predicateOperations.exprList();
+        if (exprList) {
+            const rightType = traverseExprList(exprList, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return rightType;
+        }
+    }
+    if (predicateOperations instanceof ts_mysql_parser_1.PredicateExprLikeContext) {
+        const simpleExpr = predicateOperations.simpleExpr()[0];
+        const rightType = traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+        constraints.push({
+            expression: simpleExpr.text,
+            type1: parentType,
+            type2: rightType
+        });
+        return rightType;
+    }
+    throw Error("Not expected");
+}
+function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    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);
+        const column = (0, select_columns_1.findColumn)(fieldName, fromColumns.concat(withSchema));
+        const typeVar = (0, collect_constraints_1.freshVar)(column.columnName, column.columnType.type, column.tableAlias || column.table);
+        constraints.push({
+            expression: simpleExpr.text,
+            type1: typeVar,
+            type2: column.columnType,
+            mostGeneralType: true
+        });
+        return typeVar;
+    }
+    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprParamMarkerContext) {
+        const param = (0, collect_constraints_1.freshVar)('?', '?');
+        parameters.push(param);
+        return param;
+    }
+    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprLiteralContext) {
+        const literal = simpleExpr.literal();
+        if (literal.textLiteral()) {
+            const text = ((_a = literal.textLiteral()) === null || _a === void 0 ? void 0 : _a.text.slice(1, -1)) || ''; //remove quotes
+            return (0, collect_constraints_1.freshVar)(text, 'varchar');
+        }
+        const numLiteral = literal.numLiteral();
+        if (numLiteral) {
+            return (0, collect_constraints_1.freshVar)(numLiteral.text, 'int');
+            // 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 (0, collect_constraints_1.freshVar)(boolLiteral.text, 'bit');
+        }
+        const nullLiteral = literal.nullLiteral();
+        if (nullLiteral) {
+            return (0, collect_constraints_1.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 = traverseExpr(item, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return exprType;
+        });
+        const resultType = {
+            kind: 'TypeOperator',
+            types: listType
+        };
+        return resultType;
+    }
+    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprSubQueryContext) {
+        const subquery = simpleExpr.subquery();
+        const subqueryResult = traverseSubquery(subquery, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return {
+            kind: 'TypeOperator',
+            types: subqueryResult.columns.map(t => (Object.assign(Object.assign({}, t.type), { table: '' })))
+        };
+    }
+    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprCaseContext) {
+        //case when expr then expr else expr
+        const caseType = (0, collect_constraints_1.freshVar)(simpleExpr.text, '?');
+        simpleExpr.whenExpression().forEach(whenExprCont => {
+            const whenExpr = whenExprCont.expr();
+            const whenType = traverseExpr(whenExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+            constraints.push({
+                expression: whenExpr.text,
+                type1: whenType.kind == 'TypeOperator' ? whenType.types[0] : whenType,
+                type2: (0, collect_constraints_1.freshVar)('tinyint', 'tinyint') //bool
+            });
+        });
+        const thenTypes = simpleExpr.thenExpression().map(thenExprCtx => {
+            const thenExpr = thenExprCtx.expr();
+            const thenType = traverseExpr(thenExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+            constraints.push({
+                expression: thenExprCtx.text,
+                type1: caseType,
+                type2: thenType.kind == 'TypeOperator' ? thenType.types[0] : thenType,
+                mostGeneralType: true,
+            });
+            return thenType;
+        });
+        const elseExpr = (_b = simpleExpr.elseExpression()) === null || _b === void 0 ? void 0 : _b.expr();
+        if (elseExpr) {
+            const elseType = traverseExpr(elseExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+            constraints.push({
+                expression: (_c = simpleExpr.elseExpression()) === null || _c === void 0 ? void 0 : _c.text,
+                type1: caseType,
+                type2: elseType.kind == 'TypeOperator' ? elseType.types[0] : elseType,
+                mostGeneralType: true
+            });
+            thenTypes.forEach(thenType => {
+                var _a;
+                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 = traverseExpr(exprLeft, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const typeRight = traverseExpr(exprRight, constraints, parameters, dbSchema, withSchema, fromColumns);
+        constraints.push({
+            expression: exprLeft.text,
+            type1: typeLeft,
+            type2: (0, collect_constraints_1.freshVar)('bigint', 'bigint')
+        });
+        if (typeRight.kind == 'TypeVar' && ((0, collect_constraints_1.isDateLiteral)(typeRight.name) || (0, collect_constraints_1.isDateTimeLiteral)(typeRight.name))) {
+            typeRight.type = 'datetime';
+        }
+        constraints.push({
+            expression: exprRight.text,
+            type1: typeRight,
+            type2: (0, collect_constraints_1.freshVar)('datetime', 'datetime')
+        });
+        return (0, collect_constraints_1.freshVar)('datetime', 'datetime');
+    }
+    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprSumContext) {
+        const sumExpr = simpleExpr.sumExpr();
+        if (sumExpr.MAX_SYMBOL() || sumExpr.MIN_SYMBOL()) {
+            const functionType = (0, collect_constraints_1.freshVar)(simpleExpr.text, '?');
+            const inSumExpr = (_d = sumExpr.inSumExpr()) === null || _d === void 0 ? void 0 : _d.expr();
+            if (inSumExpr) {
+                const inSumExprType = traverseExpr(inSumExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+                constraints.push({
+                    expression: simpleExpr.text,
+                    type1: functionType,
+                    type2: inSumExprType,
+                    mostGeneralType: true
+                });
+            }
+            return functionType;
+        }
+        if (sumExpr.COUNT_SYMBOL()) {
+            const functionType = (0, collect_constraints_1.freshVar)(simpleExpr.text, 'bigint');
+            const inSumExpr = (_e = sumExpr.inSumExpr()) === null || _e === void 0 ? void 0 : _e.expr();
+            if (inSumExpr) {
+                traverseExpr(inSumExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+            }
+            return functionType;
+        }
+        if (sumExpr.SUM_SYMBOL() || sumExpr.AVG_SYMBOL()) {
+            const functionType = (0, collect_constraints_1.freshVar)(simpleExpr.text, '?');
+            const inSumExpr = (_f = sumExpr.inSumExpr()) === null || _f === void 0 ? void 0 : _f.expr();
+            if (inSumExpr) {
+                const inSumExprType = traverseExpr(inSumExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+                constraints.push({
+                    expression: simpleExpr.text,
+                    type1: functionType,
+                    type2: inSumExprType,
+                    mostGeneralType: true,
+                    coercionType: 'SumFunction'
+                });
+                if (inSumExprType.kind == 'TypeVar') {
+                    functionType.table = inSumExprType.table;
+                }
+            }
+            return functionType;
+        }
+        if (sumExpr.GROUP_CONCAT_SYMBOL()) {
+            const exprList = sumExpr.exprList();
+            if (exprList) {
+                exprList.expr().map(item => {
+                    const exprType = traverseExpr(item, constraints, parameters, dbSchema, withSchema, fromColumns);
+                    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 (0, collect_constraints_1.freshVar)(sumExpr.text, 'varchar');
+                ;
+            }
+        }
+        throw Error('Expression not supported: ' + sumExpr.constructor.name);
+    }
+    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprRuntimeFunctionContext) {
+        const runtimeFunctionCall = simpleExpr.runtimeFunctionCall();
+        if (runtimeFunctionCall.NOW_SYMBOL()) {
+            return (0, collect_constraints_1.freshVar)(simpleExpr.text, 'datetime');
+        }
+        if (runtimeFunctionCall.CURDATE_SYMBOL()) {
+            return (0, collect_constraints_1.freshVar)(simpleExpr.text, 'date');
+        }
+        if (runtimeFunctionCall.CURTIME_SYMBOL()) {
+            return (0, collect_constraints_1.freshVar)(simpleExpr.text, 'time');
+        }
+        if (runtimeFunctionCall.REPLACE_SYMBOL()) {
+            const exprList = runtimeFunctionCall.expr();
+            exprList.forEach(expr => {
+                const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+                constraints.push({
+                    expression: expr.text,
+                    type1: exprType,
+                    type2: (0, collect_constraints_1.freshVar)('varchar', 'varchar')
+                });
+            });
+            return (0, collect_constraints_1.freshVar)('varchar', 'varchar');
+        }
+        if (runtimeFunctionCall.YEAR_SYMBOL() || runtimeFunctionCall.MONTH_SYMBOL() || runtimeFunctionCall.DAY_SYMBOL()) {
+            const expr = (_g = runtimeFunctionCall.exprWithParentheses()) === null || _g === void 0 ? void 0 : _g.expr();
+            if (expr) {
+                const paramType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+                if (paramType.kind == 'TypeVar' && (0, collect_constraints_1.isDateTimeLiteral)(paramType.name)) {
+                    paramType.type = 'datetime';
+                }
+                if (paramType.kind == 'TypeVar' && (0, collect_constraints_1.isDateLiteral)(paramType.name)) {
+                    paramType.type = 'date';
+                }
+                constraints.push({
+                    expression: expr.text,
+                    type1: paramType,
+                    type2: (0, collect_constraints_1.freshVar)(simpleExpr.text, 'date')
+                });
+            }
+            const returnType = runtimeFunctionCall.YEAR_SYMBOL() ? 'year' : 'tinyint';
+            return (0, collect_constraints_1.freshVar)(simpleExpr.text, returnType);
+        }
+        if (runtimeFunctionCall.HOUR_SYMBOL() || runtimeFunctionCall.MINUTE_SYMBOL() || runtimeFunctionCall.SECOND_SYMBOL()) {
+            const expr = (_h = runtimeFunctionCall.exprWithParentheses()) === null || _h === void 0 ? void 0 : _h.expr();
+            if (expr) {
+                const paramType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+                if (paramType.kind == 'TypeVar' && (0, collect_constraints_1.isTimeLiteral)(paramType.name)) {
+                    paramType.type = 'time';
+                }
+                if (paramType.kind == 'TypeVar' && (0, collect_constraints_1.isDateLiteral)(paramType.name)) {
+                    paramType.type = 'date';
+                }
+                if (paramType.kind == 'TypeVar' && (0, collect_constraints_1.isDateTimeLiteral)(paramType.name)) {
+                    paramType.type = 'datetime';
+                }
+                constraints.push({
+                    expression: expr.text,
+                    type1: paramType,
+                    type2: (0, collect_constraints_1.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 (0, collect_constraints_1.freshVar)(simpleExpr.text, returnType);
+        }
+        const trimFunction = runtimeFunctionCall.trimFunction();
+        if (trimFunction) {
+            const exprList = trimFunction.expr();
+            if (exprList.length == 1) {
+                const exprType = traverseExpr(exprList[0], constraints, parameters, dbSchema, withSchema, fromColumns);
+                constraints.push({
+                    expression: exprList[0].text,
+                    type1: exprType,
+                    type2: (0, collect_constraints_1.freshVar)('varchar', 'varchar')
+                });
+            }
+            if (exprList.length == 2) {
+                const exprType = traverseExpr(exprList[0], constraints, parameters, dbSchema, withSchema, fromColumns);
+                const expr2Type = traverseExpr(exprList[1], constraints, parameters, dbSchema, withSchema, fromColumns);
+                constraints.push({
+                    expression: exprList[0].text,
+                    type1: exprType,
+                    type2: (0, collect_constraints_1.freshVar)('varchar', 'varchar')
+                });
+                constraints.push({
+                    expression: exprList[1].text,
+                    type1: expr2Type,
+                    type2: (0, collect_constraints_1.freshVar)('varchar', 'varchar')
+                });
+            }
+            return (0, collect_constraints_1.freshVar)('varchar', 'varchar');
+        }
+        const substringFunction = runtimeFunctionCall.substringFunction();
+        if (substringFunction) {
+            const exprList = substringFunction.expr();
+            const varcharParam = (0, collect_constraints_1.freshVar)('varchar', 'varchar');
+            const intParam = (0, collect_constraints_1.freshVar)('int', 'int');
+            const params = {
+                kind: 'FixedLengthParams',
+                paramsType: [varcharParam, intParam, intParam]
+            };
+            traverseExprListParameters(exprList, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            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 = traverseExpr(expr1, constraints, parameters, dbSchema, withSchema, fromColumns);
+            const typeExpr2 = traverseExpr(expr2, constraints, parameters, dbSchema, withSchema, fromColumns);
+            if (typeExpr1.kind == 'TypeVar' && ((0, collect_constraints_1.isDateLiteral)(typeExpr1.name) || (0, collect_constraints_1.isDateTimeLiteral)(typeExpr1.name))) {
+                typeExpr1.type = 'datetime';
+            }
+            constraints.push({
+                expression: expr1.text,
+                type1: typeExpr1,
+                type2: (0, collect_constraints_1.freshVar)('datetime', 'datetime')
+            });
+            constraints.push({
+                expression: expr2.text,
+                type1: typeExpr2,
+                type2: (0, collect_constraints_1.freshVar)('bigint', 'bigint')
+            });
+            return (0, collect_constraints_1.freshVar)('datetime', 'datetime');
+        }
+        if (runtimeFunctionCall.COALESCE_SYMBOL()) {
+            const exprList = (_j = runtimeFunctionCall.exprListWithParentheses()) === null || _j === void 0 ? void 0 : _j.exprList().expr();
+            if (exprList) {
+                const paramType = (0, collect_constraints_1.freshVar)('COALESCE', 'any');
+                const params = {
+                    kind: 'VariableLengthParams',
+                    paramType: '?'
+                };
+                const paramsTypeList = traverseExprListParameters(exprList, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+                paramsTypeList.forEach((typeVar, paramIndex) => {
+                    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 = (0, collect_constraints_1.freshVar)('number', 'number');
+            const exprList = runtimeFunctionCall.expr();
+            const param1 = traverseExpr(exprList[0], constraints, parameters, dbSchema, withSchema, fromColumns);
+            const param2 = traverseExpr(exprList[1], constraints, parameters, dbSchema, withSchema, fromColumns);
+            constraints.push({
+                expression: simpleExpr.text,
+                type1: (0, collect_constraints_1.freshVar)('number', 'number'),
+                type2: param1,
+                mostGeneralType: true,
+                coercionType: 'Numeric'
+            });
+            constraints.push({
+                expression: simpleExpr.text,
+                type1: (0, collect_constraints_1.freshVar)('number', 'number'),
+                type2: param2,
+                mostGeneralType: true,
+                coercionType: 'Numeric'
+            });
+            constraints.push({
+                expression: simpleExpr.text,
+                type1: functionType,
+                type2: param1,
+                mostGeneralType: true
+            });
+            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];
+            traverseExpr(expr1, constraints, parameters, dbSchema, withSchema, fromColumns);
+            const expr2Type = traverseExpr(expr2, constraints, parameters, dbSchema, withSchema, fromColumns);
+            const expr3Type = traverseExpr(expr3, constraints, parameters, dbSchema, withSchema, fromColumns);
+            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 = (0, collect_constraints_1.getFunctionName)(simpleExpr);
+        if (functionIdentifier === 'concat_ws' || (functionIdentifier === null || functionIdentifier === void 0 ? void 0 : functionIdentifier.toLowerCase()) === 'concat') {
+            const varcharType = (0, collect_constraints_1.freshVar)(simpleExpr.text, 'varchar');
+            const params = {
+                kind: 'VariableLengthParams',
+                paramType: 'varchar'
+            };
+            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return varcharType;
+        }
+        if (functionIdentifier === 'avg') {
+            const functionType = (0, collect_constraints_1.freshVar)(simpleExpr.text, '?');
+            constraints.push({
+                expression: simpleExpr.text,
+                type1: functionType,
+                type2: (0, collect_constraints_1.freshVar)('decimal', 'decimal'),
+                mostGeneralType: true
+            });
+            const params = {
+                kind: 'FixedLengthParams',
+                paramsType: [functionType]
+            };
+            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return functionType;
+        }
+        if (functionIdentifier === 'round') {
+            const functionType = (0, collect_constraints_1.freshVar)(simpleExpr.text, '?');
+            const params = {
+                kind: 'FixedLengthParams',
+                paramsType: [functionType]
+            };
+            const paramsType = walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            //The return value has the same type as the first argument
+            constraints.push({
+                expression: simpleExpr.text,
+                type1: functionType,
+                type2: paramsType[0],
+                mostGeneralType: true
+            });
+            return functionType;
+        }
+        if (functionIdentifier === 'floor') {
+            const doubleParam = (0, collect_constraints_1.freshVar)('double', 'double');
+            const params = {
+                kind: 'FixedLengthParams',
+                paramsType: [doubleParam, doubleParam]
+            };
+            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return (0, collect_constraints_1.freshVar)(simpleExpr.text, 'bigint');
+        }
+        if (functionIdentifier === 'str_to_date') {
+            const varcharParam = (0, collect_constraints_1.freshVar)('varchar', 'varchar');
+            const params = {
+                kind: 'FixedLengthParams',
+                paramsType: [varcharParam, varcharParam]
+            };
+            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return (0, collect_constraints_1.freshVar)(simpleExpr.text, 'date');
+        }
+        if (functionIdentifier === 'datediff') {
+            const udfExprList = (_k = simpleExpr.functionCall().udfExprList()) === null || _k === void 0 ? void 0 : _k.udfExpr();
+            if (udfExprList) {
+                udfExprList.forEach((inExpr) => {
+                    const expr = inExpr.expr();
+                    const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+                    const newType = (0, collect_constraints_1.verifyDateTypesCoercion)(exprType);
+                    constraints.push({
+                        expression: expr.text,
+                        type1: newType,
+                        type2: (0, collect_constraints_1.freshVar)('date', 'date'),
+                        mostGeneralType: true
+                    });
+                });
+            }
+            return (0, collect_constraints_1.freshVar)(simpleExpr.text, 'bigint');
+        }
+        if (functionIdentifier === 'lpad' || functionIdentifier == 'rpad') {
+            const varcharParam = (0, collect_constraints_1.freshVar)('varchar', 'varchar');
+            const intParam = (0, collect_constraints_1.freshVar)('int', 'int');
+            const params = {
+                kind: 'FixedLengthParams',
+                paramsType: [varcharParam, intParam, varcharParam]
+            };
+            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return varcharParam;
+        }
+        if (functionIdentifier === 'lower'
+            || functionIdentifier === 'lcase'
+            || functionIdentifier === 'upper'
+            || functionIdentifier === 'ucase'
+            || functionIdentifier === 'trim'
+            || functionIdentifier === 'ltrim'
+            || functionIdentifier === 'rtrim') {
+            const varcharParam = (0, collect_constraints_1.freshVar)('varchar', 'varchar');
+            const params = {
+                kind: 'FixedLengthParams',
+                paramsType: [varcharParam]
+            };
+            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return varcharParam;
+        }
+        if (functionIdentifier === 'length' || functionIdentifier == 'char_length') {
+            const varcharParam = (0, collect_constraints_1.freshVar)('varchar', 'varchar');
+            const params = {
+                kind: 'FixedLengthParams',
+                paramsType: [varcharParam]
+            };
+            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return (0, collect_constraints_1.freshVar)('int', 'int');
+        }
+        if (functionIdentifier === 'abs') {
+            const functionType = (0, collect_constraints_1.freshVar)('number', 'number');
+            const udfExprList = (_l = simpleExpr.functionCall().udfExprList()) === null || _l === void 0 ? void 0 : _l.udfExpr();
+            udfExprList === null || udfExprList === void 0 ? void 0 : udfExprList.forEach(expr => {
+                const param1 = traverseExpr(expr.expr(), constraints, parameters, dbSchema, withSchema, fromColumns);
+                constraints.push({
+                    expression: simpleExpr.text,
+                    type1: functionType,
+                    type2: param1,
+                    mostGeneralType: true,
+                    coercionType: 'Numeric'
+                });
+            });
+            return functionType;
+        }
+        if (functionIdentifier == 'ceiling' || functionIdentifier == 'ceil') {
+            const functionType = (0, collect_constraints_1.freshVar)('number', 'number');
+            const udfExprList = (_m = simpleExpr.functionCall().udfExprList()) === null || _m === void 0 ? void 0 : _m.udfExpr();
+            udfExprList === null || udfExprList === void 0 ? void 0 : udfExprList.forEach(expr => {
+                const param1 = traverseExpr(expr.expr(), constraints, parameters, dbSchema, withSchema, fromColumns);
+                constraints.push({
+                    expression: simpleExpr.text,
+                    type1: functionType,
+                    type2: param1,
+                    mostGeneralType: true,
+                    coercionType: 'Ceiling'
+                });
+            });
+            return functionType;
+        }
+        if (functionIdentifier == 'timestampdiff') {
+            const udfExprList = (_o = simpleExpr.functionCall().udfExprList()) === null || _o === void 0 ? void 0 : _o.udfExpr();
+            if (udfExprList) {
+                const [first, ...rest] = udfExprList;
+                const unit = first.text.trim().toLowerCase();
+                rest.forEach((inExpr, paramIndex) => {
+                    const expr = inExpr.expr();
+                    const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+                    const newType = (0, collect_constraints_1.verifyDateTypesCoercion)(exprType);
+                    //const expectedType = ['hour', 'minute', 'second'].includes(unit)? 'time' : 'datetime'
+                    constraints.push({
+                        expression: expr.text,
+                        type1: newType,
+                        type2: (0, collect_constraints_1.freshVar)('datetime', 'datetime'),
+                        mostGeneralType: true
+                    });
+                });
+            }
+            return (0, collect_constraints_1.freshVar)('int', 'int');
+        }
+        if (functionIdentifier == 'ifnull' || functionIdentifier == 'nullif') {
+            const functionType = (0, collect_constraints_1.freshVar)(simpleExpr.text, '?');
+            const udfExprList = (_p = simpleExpr.functionCall().udfExprList()) === null || _p === void 0 ? void 0 : _p.udfExpr();
+            if (udfExprList) {
+                const [expr1, expr2] = udfExprList;
+                const expr1Type = traverseExpr(expr1.expr(), constraints, parameters, dbSchema, withSchema, fromColumns);
+                constraints.push({
+                    expression: expr1.text,
+                    type1: functionType,
+                    type2: expr1Type
+                });
+                const expr2Type = traverseExpr(expr2.expr(), constraints, parameters, dbSchema, withSchema, fromColumns);
+                constraints.push({
+                    expression: expr2.text,
+                    type1: functionType,
+                    type2: expr2Type
+                });
+            }
+            return functionType;
+        }
+        if (functionIdentifier == 'md5' //md5(str) - TODO - have input constraint = string
+            || functionIdentifier == 'hex' //md5(n or str)
+            || functionIdentifier == 'unhex') { //unhex (str) - TODO - have input constraint = string
+            const functionType = (0, collect_constraints_1.freshVar)(simpleExpr.text, 'char');
+            const udfExprList = (_q = simpleExpr.functionCall().udfExprList()) === null || _q === void 0 ? void 0 : _q.udfExpr();
+            if (udfExprList) {
+                const [expr1] = udfExprList;
+                const paramType = traverseExpr(expr1.expr(), constraints, parameters, dbSchema, withSchema, fromColumns);
+                constraints.push({
+                    expression: expr1.text,
+                    type1: paramType,
+                    type2: (0, collect_constraints_1.freshVar)(expr1.text, 'varchar')
+                });
+            }
+            return functionType;
+        }
+        throw Error('Function not supported: ' + functionIdentifier);
+    }
+    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprWindowingFunctionContext) {
+        const windowFunctionCall = simpleExpr.windowFunctionCall();
+        return traverseWindowFunctionCall(windowFunctionCall, constraints, parameters, dbSchema, withSchema, fromColumns);
+    }
+    if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprCastContext) {
+        const castType = simpleExpr.castType();
+        if (castType.CHAR_SYMBOL()) {
+            return (0, collect_constraints_1.freshVar)(castType.text, 'char');
+        }
+    }
+    throw Error('traverseSimpleExpr - not supported: ' + simpleExpr.constructor.name);
+}
+function traverseWindowFunctionCall(windowFunctionCall, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    if (windowFunctionCall.ROW_NUMBER_SYMBOL()
+        || windowFunctionCall.RANK_SYMBOL()
+        || windowFunctionCall.DENSE_RANK_SYMBOL()
+        || windowFunctionCall.CUME_DIST_SYMBOL()
+        || windowFunctionCall.PERCENT_RANK_SYMBOL()) {
+        return (0, collect_constraints_1.freshVar)(windowFunctionCall.text, 'bigint');
+    }
+    const expr = windowFunctionCall.expr();
+    if (expr) {
+        return traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+    }
+    const exprWithParentheses = windowFunctionCall.exprWithParentheses();
+    if (exprWithParentheses) {
+        const expr = exprWithParentheses.expr();
+        return traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+    }
+    throw Error('No support for expression' + windowFunctionCall.constructor.name);
+}
+function traverseExprListParameters(exprList, params, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    return exprList.map((expr, paramIndex) => {
+        const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const paramType = params.kind == 'FixedLengthParams' ? params.paramsType[paramIndex] : (0, collect_constraints_1.freshVar)(params.paramType, params.paramType);
+        constraints.push({
+            expression: expr.text,
+            type1: exprType,
+            type2: paramType,
+            mostGeneralType: true
+        });
+        return paramType;
+    });
+}
+function walkFunctionParameters(simpleExprFunction, params, constraints, parameters, dbSchema, withSchema, fromColumns) {
+    var _a, _b;
+    const functionName = (0, collect_constraints_1.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 = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+            constraints.push({
+                expression: expr.text,
+                type1: exprType,
+                type2: params.kind == 'FixedLengthParams' ? params.paramsType[paramIndex] : (0, collect_constraints_1.freshVar)(params.paramType, params.paramType),
+            });
+            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 = traverseExpr(inExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+            constraints.push({
+                expression: inExpr.text,
+                type1: params.kind == 'FixedLengthParams' ? params.paramsType[paramIndex] : (0, collect_constraints_1.freshVar)(params.paramType, params.paramType),
+                type2: inSumExprType,
+                mostGeneralType: true
+            });
+            return inSumExprType;
+        });
+        return paramTypes;
+    }
+    throw Error('Error in walkFunctionParameters');
+}
+function filterColumns(dbSchema, withSchema, tableAlias, table) {
+    const withResult = withSchema.filter(t => t.table.toLowerCase() == table.name.toLowerCase()).map(s => (Object.assign(Object.assign({}, s), { tableAlias: tableAlias })));
+    const tableColumns1 = dbSchema
+        .filter(schema => schema.table.toLowerCase() == table.name.toLowerCase() && (schema.schema == table.prefix || table.prefix == ''))
+        .map(tableColumn => {
+        //name and colum are the same on the leaf table
+        const r = {
+            columnName: tableColumn.column, columnType: (0, collect_constraints_1.createColumnTypeFomColumnSchema)(tableColumn),
+            notNull: tableColumn.notNull, table: table.name, tableAlias: tableAlias || '', columnKey: tableColumn.columnKey
+        };
+        return r;
+    });
+    const result = tableColumns1.concat(withResult);
+    return result;
+}
+exports.filterColumns = filterColumns;
+function selectAllColumns(tablePrefix, fromColumns) {
+    return fromColumns.filter(column => {
+        if (tablePrefix == '' || tablePrefix == column.tableAlias || tablePrefix == column.table) {
+            return true;
+        }
+        return false;
+    });
+}
+exports.selectAllColumns = selectAllColumns;
+function filterUsingFields(joinedFields, usingFields) {
+    return joinedFields.filter(joinedField => {
+        const isUsing = usingFields.includes(joinedField.columnName);
+        if (!isUsing) {
+            return true;
+        }
+        return false;
+    });
+}
+function isMultipleRowResult(selectStatement, fromColumns) {
+    var _a, _b;
+    const querySpecs = (0, parse_1.getAllQuerySpecificationsFromSelectStatement)(selectStatement);
+    if (querySpecs.length == 1) { //UNION queries are multipleRowsResult = true
+        const fromClause = querySpecs[0].fromClause();
+        if (!fromClause) {
+            return false;
+        }
+        if (querySpecs[0].selectItemList().childCount == 1) {
+            const selectItem = querySpecs[0].selectItemList().getChild(0);
+            //if selectItem = * (TerminalNode) childCount = 0; selectItem.expr() throws exception
+            const expr = selectItem.childCount > 0 ? selectItem.expr() : null;
+            if (expr) {
+                //SUM, MAX... WITHOUT GROUP BY are multipleRowsResult = false
+                const groupBy = querySpecs[0].groupByClause();
+                if (!groupBy && (0, parse_1.isSumExpressContext)(expr)) {
+                    return false;
+                }
+            }
+        }
+        const joinedTable = (_a = fromClause.tableReferenceList()) === null || _a === void 0 ? void 0 : _a.tableReference()[0].joinedTable();
+        if (joinedTable && joinedTable.length > 0) {
+            return true;
+        }
+        const whereClauseExpr = (_b = querySpecs[0].whereClause()) === null || _b === void 0 ? void 0 : _b.expr();
+        const isMultipleRowResult = whereClauseExpr && verifyMultipleResult2(whereClauseExpr, fromColumns);
+        if (isMultipleRowResult == false) {
+            return false;
+        }
+    }
+    const limitOptions = (0, parse_1.getLimitOptions)(selectStatement);
+    if (limitOptions.length == 1 && limitOptions[0].text == '1') {
+        return false;
+    }
+    if (limitOptions.length == 2 && limitOptions[1].text == '1') {
+        return false;
+    }
+    return true;
+}
+exports.isMultipleRowResult = isMultipleRowResult;
+function verifyMultipleResult2(exprContext, fromColumns) {
+    if (exprContext instanceof ts_mysql_parser_1.ExprIsContext) {
+        const boolPri = exprContext.boolPri();
+        if (boolPri instanceof ts_mysql_parser_1.PrimaryExprCompareContext) {
+            if (boolPri.compOp().EQUAL_OPERATOR()) {
+                let compareLeft = boolPri.boolPri();
+                let compareRight = boolPri.predicate();
+                if (isUniqueKeyComparation(compareLeft, fromColumns) || isUniqueKeyComparation(compareRight, fromColumns)) {
+                    return false; //multipleRow = false
+                }
+            }
+            return true; //multipleRow = true
+        }
+        return true; //multipleRow
+    }
+    if (exprContext instanceof ts_mysql_parser_1.ExprNotContext) {
+        return true;
+    }
+    if (exprContext instanceof ts_mysql_parser_1.ExprAndContext) {
+        const oneIsSingleResult = exprContext.expr().some(expr => verifyMultipleResult2(expr, fromColumns) == false);
+        return oneIsSingleResult == false;
+    }
+    // if (exprContext instanceof ExprXorContext) {
+    //     const expressions = exprContext.expr();
+    // }
+    if (exprContext instanceof ts_mysql_parser_1.ExprOrContext) {
+        return true; //multipleRow = true
+    }
+    throw Error('Unknow type:' + exprContext.constructor.name);
+}
+exports.verifyMultipleResult2 = verifyMultipleResult2;
+function isUniqueKeyComparation(compare, fromColumns) {
+    const tokens = (0, select_columns_1.getSimpleExpressions)(compare);
+    if (tokens.length == 1 && tokens[0] instanceof ts_mysql_parser_1.SimpleExprColumnRefContext) {
+        const fieldName = (0, select_columns_1.splitName)(tokens[0].text);
+        const col = (0, select_columns_1.findColumn)(fieldName, fromColumns);
+        if (col.columnKey == 'PRI' || col.columnKey == 'UNI') { //TODO - UNIQUE
+            return true; //isUniqueKeyComparation = true
+        }
+    }
+    return false; //isUniqueKeyComparation = false
+}
+function getOrderByColumns(fromColumns, selectColumns) {
+    const fromColumnsNames = fromColumns.map(col => col.columnName); //TODO - loading twice
+    const selectColumnsNames = selectColumns.map(col => col.name);
+    const allOrderByColumns = Array.from(new Set(fromColumnsNames.concat(selectColumnsNames)));
+    return allOrderByColumns;
+}
+//# sourceMappingURL=traverse.js.map