typesql-cli 0.6.20 → 0.7.0

package/mysql-query-analyzer/traverse.js

@@ -13,36 +13,48 @@ function traverseQueryContext(queryContext, dbSchema, namedParameters) {
     var _a, _b, _c, _d;
     const constraints = [];
     const parameters = [];
+    const traverseContext = {
+        constraints,
+        dbSchema,
+        parameters,
+        fromColumns: [],
+        withSchema: [],
+        dynamicSqlInfo: {
+            select: [],
+            from: [],
+            where: []
+        }
+    };
     const selectStatement = (_a = queryContext.simpleStatement()) === null || _a === void 0 ? void 0 : _a.selectStatement();
     if (selectStatement) {
-        const typeInfer = traverseSelectStatement(selectStatement, constraints, parameters, dbSchema, namedParameters);
+        const typeInfer = traverseSelectStatement(selectStatement, traverseContext, namedParameters);
         return typeInfer;
     }
     const insertStatement = (_b = queryContext.simpleStatement()) === null || _b === void 0 ? void 0 : _b.insertStatement();
     if (insertStatement) {
-        return traverseInsertStatement(insertStatement, constraints, parameters, dbSchema);
+        return traverseInsertStatement(insertStatement, traverseContext);
     }
     const updateStatement = (_c = queryContext.simpleStatement()) === null || _c === void 0 ? void 0 : _c.updateStatement();
     if (updateStatement) {
-        const typeInfer = traverseUpdateStatement(updateStatement, constraints, parameters, dbSchema, namedParameters);
+        const typeInfer = traverseUpdateStatement(updateStatement, traverseContext, 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);
+        const typeInfer = traverseDeleteStatement(deleteStatement, traverseContext);
         return typeInfer;
     }
     throw Error('traverseSql - not supported: ' + queryContext.constructor.name);
 }
 exports.traverseQueryContext = traverseQueryContext;
-function traverseSelectStatement(selectStatement, constraints, parameters, dbSchema, namedParameters) {
+function traverseSelectStatement(selectStatement, traverseContext, namedParameters) {
     const queryExpression = selectStatement.queryExpression();
     if (queryExpression) {
-        const result = traverseQueryExpression(queryExpression, constraints, parameters, dbSchema, [], []);
+        const result = traverseQueryExpression(queryExpression, traverseContext);
         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
+        const allParameters = traverseContext.parameters
             .map((param, index) => {
             const param2 = {
                 name: param.name,
@@ -55,7 +67,7 @@ function traverseSelectStatement(selectStatement, constraints, parameters, dbSch
         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({
+                traverseContext.constraints.push({
                     expression: paramIndex.paramName,
                     type1: allParameters[cur].type,
                     type2: allParameters[next].type
@@ -65,11 +77,12 @@ function traverseSelectStatement(selectStatement, constraints, parameters, dbSch
         const isMultiRow = isMultipleRowResult(selectStatement, result.fromColumns);
         const traverseResult = {
             type: 'Select',
-            constraints,
+            constraints: traverseContext.constraints,
             columns: result.columns,
             parameters: allParameters,
             limitParameters,
-            isMultiRow
+            isMultiRow,
+            dynamicSqlInfo: traverseContext.dynamicSqlInfo
         };
         const orderByColumns = orderByParameters.length > 0 ? getOrderByColumns(result.fromColumns, result.columns) : undefined;
         if (orderByColumns) {
@@ -79,7 +92,7 @@ function traverseSelectStatement(selectStatement, constraints, parameters, dbSch
     }
     throw Error('traverseSelectStatement - not supported: ' + selectStatement.text);
 }
-function traverseInsertStatement(insertStatement, constraints, parameters, dbSchema) {
+function traverseInsertStatement(insertStatement, traverseContext) {
     var _a, _b;
     const allParameters = [];
     const paramsNullability = {};
@@ -89,7 +102,7 @@ function traverseInsertStatement(insertStatement, constraints, parameters, dbSch
         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
+    const fromColumns = traverseContext.dbSchema
         .filter(c => c.table == insertIntoTable)
         .map(c => {
         const col = {
@@ -102,17 +115,18 @@ function traverseInsertStatement(insertStatement, constraints, parameters, dbSch
         return col;
     });
     const insertColumns = (0, collect_constraints_1.getInsertColumns)(insertStatement, fromColumns);
+    traverseContext.fromColumns = insertColumns;
     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 numberParamsBefore = traverseContext.parameters.length;
+                const exprType = traverseExpr(expr, traverseContext);
                 const paramNullabilityExpr = (0, infer_param_nullability_1.inferParamNullability)(expr);
-                parameters.slice(numberParamsBefore).forEach(param => {
+                traverseContext.parameters.slice(numberParamsBefore).forEach(param => {
                     paramsNullability[param.id] = paramNullabilityExpr.every(n => n) && column.notNull;
                 });
-                constraints.push({
+                traverseContext.constraints.push({
                     expression: expr.text,
                     //TODO - CHANGING ORDER SHOULDN'T AFFECT THE TYPE INFERENCE
                     type1: exprType.kind == 'TypeOperator' ? exprType.types[0] : exprType,
@@ -129,13 +143,13 @@ function traverseInsertStatement(insertStatement, constraints, parameters, dbSch
         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 numberParamsBefore = traverseContext.parameters.length;
+            const exprType = traverseExpr(expr, traverseContext);
             const column = (0, select_columns_1.findColumn)(field, fromColumns);
-            parameters.slice(numberParamsBefore).forEach(param => {
+            traverseContext.parameters.slice(numberParamsBefore).forEach(param => {
                 paramsNullability[param.id] = column.notNull;
             });
-            constraints.push({
+            traverseContext.constraints.push({
                 expression: expr.text,
                 type1: exprType,
                 type2: (0, collect_constraints_1.freshVar)(column.columnName, column.columnType.type)
@@ -145,29 +159,29 @@ function traverseInsertStatement(insertStatement, constraints, parameters, dbSch
     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);
+        const numberParamsBefore = traverseContext.parameters.length;
+        const exprTypes = traverseInsertQueryExpression(insertQueryExpression, traverseContext);
         exprTypes.columns.forEach((type, index) => {
             const column = insertColumns[index];
             if (type.type.kind == 'TypeVar') {
                 paramsNullability[type.type.id] = column.notNull;
             }
-            constraints.push({
+            traverseContext.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) => {
+        traverseContext.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);
+    const typeInfo = (0, collect_constraints_1.generateTypeInfo)(traverseContext.parameters, traverseContext.constraints);
     typeInfo.forEach((param, index) => {
-        const paramId = parameters[index].id;
+        const paramId = traverseContext.parameters[index].id;
         allParameters.push({
             name: 'param' + (allParameters.length + 1),
             columnType: (0, describe_query_1.verifyNotInferred)(param),
@@ -176,40 +190,41 @@ function traverseInsertStatement(insertStatement, constraints, parameters, dbSch
     });
     const typeInferenceResult = {
         type: 'Insert',
-        constraints: constraints,
+        constraints: traverseContext.constraints,
         parameters: allParameters
     };
     return typeInferenceResult;
 }
 exports.traverseInsertStatement = traverseInsertStatement;
-function traverseUpdateStatement(updateStatement, constraints, parameters, dbSchema, namedParamters) {
+function traverseUpdateStatement(updateStatement, traverseContext, namedParamters) {
     var _a;
     const updateElement = updateStatement.updateList().updateElement();
     const withClause = updateStatement.withClause();
     const withSchema = [];
     if (withClause) {
-        traverseWithClause(withClause, constraints, parameters, dbSchema, withSchema);
+        traverseWithClause(withClause, traverseContext);
     }
-    const updateColumns = getUpdateColumns(updateStatement, constraints, parameters, dbSchema, withSchema, []);
+    const updateColumns = getUpdateColumns(updateStatement, traverseContext);
+    traverseContext.fromColumns = updateColumns;
     const dataTypes = [];
     const whereParameters = [];
-    const paramsBefore = parameters.length;
+    const paramsBefore = traverseContext.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 paramBeforeExpr = parameters.length;
-            const result = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, updateColumns);
+            const paramBeforeExpr = traverseContext.parameters.length;
+            const result = traverseExpr(expr, traverseContext);
             const columnName = updateElement.columnRef().text;
             const field = (0, select_columns_1.splitName)(columnName);
             const column = (0, select_columns_1.findColumn)(field, updateColumns);
-            constraints.push({
+            traverseContext.constraints.push({
                 expression: updateStatement.text,
                 type1: result,
                 type2: column.columnType //freshVar(column.columnName, )
             });
-            parameters.slice(paramBeforeExpr, parameters.length).forEach((param, index) => {
+            traverseContext.parameters.slice(paramBeforeExpr, traverseContext.parameters.length).forEach((param, index) => {
                 dataTypes.push({
                     name: namedParamters[paramBeforeExpr + index] || field.name,
                     type: param,
@@ -219,11 +234,11 @@ function traverseUpdateStatement(updateStatement, constraints, parameters, dbSch
             });
         }
     });
-    const paramsAfter = parameters.length;
+    const paramsAfter = traverseContext.parameters.length;
     if (whereExpr) {
-        traverseExpr(whereExpr, constraints, parameters, dbSchema, withSchema, updateColumns);
+        traverseExpr(whereExpr, traverseContext);
     }
-    parameters.slice(0, paramsBefore).forEach((param, index) => {
+    traverseContext.parameters.slice(0, paramsBefore).forEach((param, index) => {
         whereParameters.push({
             name: namedParamters[index] || 'param' + (whereParameters.length + 1),
             type: param,
@@ -231,7 +246,7 @@ function traverseUpdateStatement(updateStatement, constraints, parameters, dbSch
             table: ''
         });
     });
-    parameters.slice(paramsAfter).forEach((param, index) => {
+    traverseContext.parameters.slice(paramsAfter).forEach((param, index) => {
         whereParameters.push({
             name: namedParamters[paramsAfter + index] || 'param' + (whereParameters.length + 1),
             type: param,
@@ -241,20 +256,21 @@ function traverseUpdateStatement(updateStatement, constraints, parameters, dbSch
     });
     const typeInferenceResult = {
         type: 'Update',
-        constraints,
+        constraints: traverseContext.constraints,
         data: dataTypes,
         parameters: whereParameters
     };
     return typeInferenceResult;
 }
-function traverseDeleteStatement(deleteStatement, constraints, parameters, dbSchema) {
+function traverseDeleteStatement(deleteStatement, traverseContext) {
     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 deleteColumns = (0, collect_constraints_1.getDeleteColumns)(deleteStatement, traverseContext.dbSchema);
+    traverseContext.fromColumns = deleteColumns;
     const allParameters = [];
     if (whereExpr) {
-        traverseExpr(whereExpr, constraints, parameters, dbSchema, [], deleteColumns);
-        const typeInfo = (0, collect_constraints_1.generateTypeInfo)(parameters, constraints);
+        traverseExpr(whereExpr, traverseContext);
+        const typeInfo = (0, collect_constraints_1.generateTypeInfo)(traverseContext.parameters, traverseContext.constraints);
         const paramNullability = (0, infer_param_nullability_1.inferParamNullability)(whereExpr);
         typeInfo.forEach((param, paramIndex) => {
             allParameters.push({
@@ -266,56 +282,56 @@ function traverseDeleteStatement(deleteStatement, constraints, parameters, dbSch
     }
     const typeInferenceResult = {
         type: 'Delete',
-        constraints,
+        constraints: traverseContext.constraints,
         parameters: allParameters
     };
     return typeInferenceResult;
 }
 exports.traverseDeleteStatement = traverseDeleteStatement;
-function getUpdateColumns(updateStatement, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function getUpdateColumns(updateStatement, traverseContext) {
     const tableReferences = updateStatement.tableReferenceList().tableReference();
-    const columns = traverseTableReferenceList(tableReferences, constraints, parameters, dbSchema, withSchema, fromColumns);
+    const columns = traverseTableReferenceList(tableReferences, traverseContext, null);
     return columns;
 }
 exports.getUpdateColumns = getUpdateColumns;
-function traverseInsertQueryExpression(insertQueryExpression, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseInsertQueryExpression(insertQueryExpression, traverseContext) {
     const queryExpressionOrParens = insertQueryExpression.queryExpressionOrParens();
-    return traverseQueryExpressionOrParens(queryExpressionOrParens, constraints, parameters, dbSchema, withSchema, fromColumns);
+    return traverseQueryExpressionOrParens(queryExpressionOrParens, traverseContext);
 }
-function traverseQueryExpressionOrParens(queryExpressionOrParens, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseQueryExpressionOrParens(queryExpressionOrParens, traverseContext) {
     const queryExpression = queryExpressionOrParens.queryExpression();
     if (queryExpression) {
-        return traverseQueryExpression(queryExpression, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return traverseQueryExpression(queryExpression, traverseContext);
     }
     const queryEpressionParens = queryExpressionOrParens.queryExpressionParens();
     if (queryEpressionParens) {
-        return traverseQueryExpressionParens(queryEpressionParens, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return traverseQueryExpressionParens(queryEpressionParens, traverseContext);
     }
     throw Error("walkQueryExpressionOrParens");
 }
-function traverseQueryExpression(queryExpression, constraints, parameters, dbSchema, withSchema, fromColumns, subQuery = false, recursiveNames) {
+function traverseQueryExpression(queryExpression, traverseContext, subQuery = false, recursiveNames) {
     const withClause = queryExpression.withClause();
     if (withClause) {
-        traverseWithClause(withClause, constraints, parameters, dbSchema, withSchema);
+        traverseWithClause(withClause, traverseContext);
     }
     const queryExpressionBody = queryExpression.queryExpressionBody();
     if (queryExpressionBody) {
-        return traverseQueryExpressionBody(queryExpressionBody, constraints, parameters, dbSchema, withSchema, fromColumns, subQuery, recursiveNames);
+        return traverseQueryExpressionBody(queryExpressionBody, traverseContext, subQuery, recursiveNames);
     }
     const queryExpressionParens = queryExpression.queryExpressionParens();
     if (queryExpressionParens) {
-        return traverseQueryExpressionParens(queryExpressionParens, constraints, parameters, dbSchema, withSchema, fromColumns, recursiveNames);
+        return traverseQueryExpressionParens(queryExpressionParens, traverseContext, recursiveNames);
     }
     throw Error("walkQueryExpression");
 }
-function traverseQueryExpressionParens(queryExpressionParens, constraints, parameters, dbSchema, withSchema, fromColumns, recursiveNames) {
+function traverseQueryExpressionParens(queryExpressionParens, traverseContext, recursiveNames) {
     const queryExpression = queryExpressionParens.queryExpression();
     if (queryExpression) {
-        return traverseQueryExpression(queryExpression, constraints, parameters, dbSchema, withSchema, fromColumns, false, recursiveNames);
+        return traverseQueryExpression(queryExpression, traverseContext, false, recursiveNames);
     }
     const queryExpressionParens2 = queryExpressionParens.queryExpressionParens();
     if (queryExpressionParens2) {
-        return traverseQueryExpressionParens(queryExpressionParens, constraints, parameters, dbSchema, withSchema, fromColumns, recursiveNames);
+        return traverseQueryExpressionParens(queryExpressionParens, traverseContext, recursiveNames);
     }
     throw Error("walkQueryExpressionParens");
 }
@@ -323,19 +339,19 @@ function createUnionVar(type, name) {
     const newVar = Object.assign(Object.assign({}, type), { name: name, table: '' });
     return newVar;
 }
-function traverseQueryExpressionBody(queryExpressionBody, constraints, parameters, dbSchema, withSchema, fromColumns, subQuery = false, recursiveNames) {
+function traverseQueryExpressionBody(queryExpressionBody, traverseContext, subQuery = false, recursiveNames) {
     const allQueries = (0, parse_1.getAllQuerySpecificationsFromSelectStatement)(queryExpressionBody);
     const [first, ...unionQuerySpec] = allQueries;
-    const mainQueryResult = traverseQuerySpecification(first, constraints, parameters, dbSchema, withSchema, fromColumns, subQuery);
+    const mainQueryResult = traverseQuerySpecification(first, traverseContext, subQuery);
     const resultTypes = mainQueryResult.columns.map((t, index) => unionQuerySpec.length == 0 ? t.type : createUnionVar(t.type, recursiveNames && recursiveNames.length > 0 ? recursiveNames[index] : t.name)); //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) : [];
         const unionQuery = unionQuerySpec[queryIndex];
-        const unionResult = traverseQuerySpecification(unionQuery, constraints, parameters, dbSchema, withSchema, newFromColumns, subQuery);
+        const unionResult = traverseQuerySpecification(unionQuery, Object.assign(Object.assign({}, traverseContext), { fromColumns: newFromColumns }), subQuery);
         resultTypes.forEach((t2, index) => {
             mainQueryResult.columns[index].notNull = mainQueryResult.columns[index].notNull && unionResult.columns[index].notNull;
-            constraints.push({
+            traverseContext.constraints.push({
                 expression: 'union',
                 coercionType: 'Union',
                 mostGeneralType: true,
@@ -372,18 +388,18 @@ function renameFromColumns(fromColumns, recursiveNames) {
     });
     return newFromColumns;
 }
-function traverseQuerySpecification(querySpec, constraints, parameters, dbSchema, withSchema, fromColumnsParent, subQuery = false) {
+function traverseQuerySpecification(querySpec, traverseContext, 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 fromColumnsFrom = fromClause ? traverseFromClause(fromClause, traverseContext, subQuery) : [];
+    const allColumns = subQuery ? traverseContext.fromColumns.concat(fromColumnsFrom) : fromColumnsFrom; //(... where id = t1.id)
+    const selectItemListResult = traverseSelectItemList(querySpec.selectItemList(), Object.assign(Object.assign({}, traverseContext), { fromColumns: allColumns }), subQuery);
     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);
+        traverseExpr(whereExpr, Object.assign(Object.assign({}, traverseContext), { fromColumns: allColumns }), !subQuery);
     }
-    const columnNullability = (0, infer_column_nullability_1.inferNotNull)(querySpec, dbSchema, allColumns);
+    const columnNullability = (0, infer_column_nullability_1.inferNotNull)(querySpec, traverseContext.dbSchema, allColumns);
     const columns = selectItemListResult.types.map((t, index) => {
         const resultType = {
             name: t.name,
@@ -405,22 +421,22 @@ function traverseQuerySpecification(querySpec, constraints, parameters, dbSchema
             };
             return col;
         });
-        traverseHavingClause(havingClause, constraints, parameters, dbSchema, withSchema, selectColumns.concat(fromColumns));
+        traverseHavingClause(havingClause, Object.assign(Object.assign({}, traverseContext), { fromColumns: selectColumns.concat(fromColumnsFrom) }));
     }
     return {
         columns,
-        fromColumns
+        fromColumns: fromColumnsFrom
     };
 }
 exports.traverseQuerySpecification = traverseQuerySpecification;
-function traverseWithClause(withClause, constraints, parameters, dbSchema, withSchema) {
+function traverseWithClause(withClause, traverseContext) {
     //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??
+        const subqueryResult = traverseSubquery(subQuery, traverseContext, recursiveNames); //recursive= true??
         subqueryResult.columns.forEach(col => {
             const withCol = {
                 table: identifier,
@@ -429,24 +445,35 @@ function traverseWithClause(withClause, constraints, parameters, dbSchema, withS
                 columnKey: "",
                 notNull: col.notNull
             };
-            withSchema.push(withCol);
+            traverseContext.withSchema.push(withCol);
         });
     });
 }
 exports.traverseWithClause = traverseWithClause;
-function traverseFromClause(fromClause, constraints, parameters, dbSchema, withSchema, fromColumnsParent) {
+function traverseFromClause(fromClause, traverseContext, subQuery = false) {
     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) : [];
+    const fromColumns = tableReferenceList ? traverseTableReferenceList(tableReferenceList, traverseContext, null, subQuery) : [];
     return fromColumns;
 }
-function traverseTableReferenceList(tableReferenceList, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseTableReferenceList(tableReferenceList, traverseContext, currentFragment, subQuery = false) {
     const result = [];
+    const fragements = [];
     tableReferenceList.forEach(tab => {
         const tableFactor = tab.tableFactor();
         if (tableFactor) {
-            const fields = traverseTableFactor(tableFactor, constraints, parameters, dbSchema, withSchema, fromColumns);
+            let paramBefore = traverseContext.parameters.length;
+            const fields = traverseTableFactor(tableFactor, traverseContext, currentFragment);
+            let paramsAfter = traverseContext.parameters.length;
             result.push(...fields);
+            fragements.push({
+                fragment: 'FROM ' + (0, select_columns_1.extractOriginalSql)(tableFactor) + '',
+                fields: [],
+                dependOnFields: [],
+                dependOnParams: [],
+                parameters: Array.from({ length: paramsAfter - paramBefore }, (x, i) => i + paramBefore),
+                dependOn: []
+            });
         }
         const allJoinedColumns = [];
         let firstLeftJoinIndex = -1;
@@ -460,11 +487,28 @@ function traverseTableReferenceList(tableReferenceList, constraints, parameters,
             }
             const tableReferences = joined.tableReference();
             if (tableReferences) {
+                const innerJoinFragment = {
+                    fragment: (0, select_columns_1.extractOriginalSql)(joined) + '',
+                    fields: [],
+                    dependOnFields: [],
+                    dependOnParams: [],
+                    parameters: [],
+                    dependOn: []
+                };
                 const usingFields = (0, select_columns_1.extractFieldsFromUsingClause)(joined);
-                const joinedFields = traverseTableReferenceList([tableReferences], constraints, parameters, dbSchema, withSchema, fromColumns);
+                const paramsBefore = traverseContext.parameters.length;
+                const joinedFields = traverseTableReferenceList([tableReferences], traverseContext, innerJoinFragment);
+                const paramsAfter = traverseContext.parameters.length;
                 //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);
+                innerJoinFragment.fields = [...joinedFieldsFiltered.map(f => ({
+                        field: f.columnName,
+                        table: f.tableAlias || f.table,
+                        name: f.columnName
+                    }))];
+                innerJoinFragment.parameters = Array.from({ length: paramsAfter - paramsBefore }, (x, i) => i + paramsAfter - 1);
+                fragements.push(innerJoinFragment);
                 const onClause = joined.expr(); //ON expr
                 if (onClause) {
                     joinedFieldsFiltered.forEach(field => {
@@ -482,7 +526,14 @@ function traverseTableReferenceList(tableReferenceList, constraints, parameters,
                         };
                         field.notNull = field.notNull || !(0, infer_column_nullability_1.possibleNull)(fieldName, onClause);
                     });
-                    traverseExpr(onClause, constraints, parameters, dbSchema, withSchema, allJoinedColumns.flatMap(c => c).concat(result));
+                    traverseExpr(onClause, Object.assign(Object.assign({}, traverseContext), { fromColumns: allJoinedColumns.flatMap(c => c).concat(result) }));
+                    const columns = (0, select_columns_1.getExpressions)(onClause, ts_mysql_parser_1.SimpleExprColumnRefContext);
+                    columns.forEach(columnRef => {
+                        const fieldName = (0, select_columns_1.splitName)(columnRef.text);
+                        if ((innerJoinFragment === null || innerJoinFragment === void 0 ? void 0 : innerJoinFragment.relation) != fieldName.prefix) {
+                            innerJoinFragment.parentRelation = fieldName.prefix;
+                        }
+                    });
                 }
             }
         });
@@ -498,20 +549,26 @@ function traverseTableReferenceList(tableReferenceList, constraints, parameters,
             });
         });
     });
+    if (!subQuery) {
+        traverseContext.dynamicSqlInfo.from = fragements;
+    }
     return result;
 }
-function traverseTableFactor(tableFactor, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseTableFactor(tableFactor, traverseContext, currentFragment) {
     var _a;
     const singleTable = tableFactor.singleTable();
     if (singleTable) {
-        return traverseSingleTable(singleTable, constraints, parameters, dbSchema, withSchema);
+        return traverseSingleTable(singleTable, traverseContext.dbSchema, traverseContext.withSchema, currentFragment);
     }
     const derivadTable = tableFactor.derivedTable();
     if (derivadTable) {
         const tableAlias = (_a = derivadTable.tableAlias()) === null || _a === void 0 ? void 0 : _a.identifier().text;
+        if (currentFragment) {
+            currentFragment.relation = tableAlias;
+        }
         const subQuery = derivadTable.subquery();
         if (subQuery) {
-            const subQueryResult = traverseSubquery(subQuery, constraints, parameters, dbSchema, withSchema, fromColumns);
+            const subQueryResult = traverseSubquery(subQuery, traverseContext);
             const result = subQueryResult.columns.map(t => {
                 const colDef = {
                     table: tableAlias || '',
@@ -528,57 +585,78 @@ function traverseTableFactor(tableFactor, constraints, parameters, dbSchema, wit
     }
     const tableReferenceListParens = tableFactor.tableReferenceListParens();
     if (tableReferenceListParens) {
-        const listParens = traverseTableReferenceListParens(tableReferenceListParens, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const listParens = traverseTableReferenceListParens(tableReferenceListParens, traverseContext);
         return listParens;
     }
     throw Error('traverseTableFactor - not supported: ' + tableFactor.constructor.name);
 }
 //tableReferenceList | tableReferenceListParens
-function traverseTableReferenceListParens(ctx, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseTableReferenceListParens(ctx, traverseContext) {
     const tableReferenceList = ctx.tableReferenceList();
     if (tableReferenceList) {
-        return traverseTableReferenceList(tableReferenceList.tableReference(), constraints, parameters, dbSchema, withSchema, fromColumns);
+        return traverseTableReferenceList(tableReferenceList.tableReference(), traverseContext, null);
     }
     const tableReferenceListParens = ctx.tableReferenceListParens();
     if (tableReferenceListParens) {
-        return traverseTableReferenceListParens(tableReferenceListParens, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return traverseTableReferenceListParens(tableReferenceListParens, traverseContext);
     }
     throw Error('traverseTableReferenceListParens - not supported: ' + ctx.constructor.name);
 }
-function traverseSingleTable(singleTable, constraints, parameters, dbSchema, withSchema) {
+function traverseSingleTable(singleTable, dbSchema, withSchema, currentFragment) {
     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);
+    if (currentFragment) {
+        currentFragment.relation = tableAlias || tableName.name;
+    }
     const fields = filterColumns(dbSchema, withSchema, tableAlias, tableName);
     return fields;
 }
-function traverseSubquery(subQuery, constraints, parameters, dbSchema, fromColumns, withSchema, recursiveNames) {
+function traverseSubquery(subQuery, traverseContext, recursiveNames) {
     const queryExpressionParens = subQuery.queryExpressionParens();
     const queryExpression = queryExpressionParens.queryExpression();
     if (queryExpression) {
-        return traverseQueryExpression(queryExpression, constraints, parameters, dbSchema, fromColumns, withSchema, true, recursiveNames);
+        return traverseQueryExpression(queryExpression, traverseContext, true, recursiveNames);
     }
     const queryExpressionParens2 = queryExpressionParens.queryExpressionParens();
     if (queryExpressionParens2) {
-        return traverseQueryExpressionParens(queryExpressionParens2, constraints, parameters, dbSchema, fromColumns, withSchema);
+        return traverseQueryExpressionParens(queryExpressionParens2, traverseContext);
     }
     throw Error('traverseSubquery - not expected: ' + subQuery.constructor.name);
 }
-function traverseSelectItemList(selectItemList, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseSelectItemList(selectItemList, traverseContext, subQuery = false) {
     const listType = [];
     if (selectItemList.MULT_OPERATOR()) {
-        fromColumns.forEach(col => {
+        traverseContext.fromColumns.forEach(col => {
             const columnType = (0, collect_constraints_1.createColumnType)(col);
             listType.push(columnType);
+            const tableName = col.tableAlias || col.table;
+            const fieldFragment = {
+                fragment: `${tableName}.${col.columnName}`,
+                fragementWithoutAlias: `${tableName}.${col.columnName}`,
+                fields: [{
+                        field: col.columnName,
+                        name: col.columnName,
+                        table: tableName
+                    }],
+                dependOnFields: [],
+                dependOnParams: [],
+                parameters: [],
+                dependOn: []
+            };
+            if (!subQuery) {
+                traverseContext.dynamicSqlInfo.select.push(fieldFragment);
+            }
         });
     }
     selectItemList.selectItem().forEach(selectItem => {
+        var _a;
         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);
+                const allColumns = selectAllColumns(itemName.prefix, traverseContext.fromColumns);
                 allColumns.forEach(col => {
                     const columnType = (0, collect_constraints_1.createColumnType)(col);
                     listType.push(columnType);
@@ -587,7 +665,32 @@ function traverseSelectItemList(selectItemList, constraints, parameters, dbSchem
         }
         const expr = selectItem.expr();
         if (expr) {
-            const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+            const exprType = traverseExpr(expr, traverseContext);
+            const selectFragment = {
+                fragment: (0, select_columns_1.extractOriginalSql)(selectItem) + '',
+                fragementWithoutAlias: (0, select_columns_1.extractOriginalSql)(expr),
+                fields: [],
+                dependOnFields: [],
+                dependOnParams: [],
+                parameters: [],
+                dependOn: []
+            };
+            if (!subQuery) {
+                (_a = traverseContext.dynamicSqlInfo.select) === null || _a === void 0 ? void 0 : _a.push(selectFragment);
+                const columns = (0, select_columns_1.getExpressions)(expr, ts_mysql_parser_1.SimpleExprColumnRefContext);
+                const columnName = (0, select_columns_1.getColumnName)(selectItem);
+                columns.forEach(colRef => {
+                    const fieldName = (0, select_columns_1.splitName)(colRef.text);
+                    const column = (0, select_columns_1.findColumn)(fieldName, traverseContext.fromColumns);
+                    selectFragment.fields.push({
+                        field: fieldName.name,
+                        name: columnName,
+                        table: column.tableAlias || column.table
+                    });
+                    selectFragment.dependOn.push(column.tableAlias || column.table);
+                });
+            }
+            // const fields = exprType.kind == 'TypeVar' ? [{ field: exprType.name, table: exprType.table + '', name: getColumnName(selectItem) }] : []
             if (exprType.kind == 'TypeOperator') {
                 const subqueryType = exprType.types[0];
                 subqueryType.name = (0, select_columns_1.getColumnName)(selectItem);
@@ -605,50 +708,104 @@ function traverseSelectItemList(selectItemList, constraints, parameters, dbSchem
     };
     return result;
 }
-function traverseHavingClause(havingClause, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseHavingClause(havingClause, traverseContext) {
     const havingExpr = havingClause.expr();
-    traverseExpr(havingExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+    traverseExpr(havingExpr, traverseContext);
 }
-function traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseExpr(expr, traverseContext, where = false) {
     if (expr instanceof ts_mysql_parser_1.ExprIsContext) {
         const boolPri = expr.boolPri();
-        const boolPriType = traverseBoolPri(boolPri, constraints, parameters, dbSchema, withSchema, fromColumns);
+        let paramsCount = traverseContext.parameters.length;
+        const boolPriType = traverseBoolPri(boolPri, traverseContext, where);
+        if (where) {
+            const currentFragment = {
+                fragment: 'AND ' + (0, select_columns_1.extractOriginalSql)(expr),
+                fields: [],
+                dependOnFields: [],
+                dependOnParams: [],
+                parameters: [],
+                dependOn: []
+            };
+            const paramsRight = (0, select_columns_1.getExpressions)(expr, ts_mysql_parser_1.SimpleExprParamMarkerContext);
+            paramsRight.forEach(_ => {
+                currentFragment.dependOnParams.push(paramsCount);
+                paramsCount++;
+            });
+            const columnsRef = (0, select_columns_1.getExpressions)(expr, ts_mysql_parser_1.ColumnRefContext);
+            columnsRef.forEach(colRef => {
+                const fileName = (0, select_columns_1.splitName)(colRef.text);
+                currentFragment.fields.push({
+                    field: fileName.name,
+                    name: fileName.name,
+                    table: fileName.prefix
+                });
+            });
+            traverseContext.dynamicSqlInfo.where.push(currentFragment);
+        }
         return boolPriType;
     }
     if (expr instanceof ts_mysql_parser_1.ExprNotContext) {
         const expr2 = expr.expr();
         if (expr2) {
-            return traverseExpr(expr2, constraints, parameters, dbSchema, withSchema, fromColumns);
+            return traverseExpr(expr2, traverseContext);
         }
         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);
+        const all = [];
+        (0, select_columns_1.getTopLevelAndExpr)(expr, all);
+        all.forEach(andExpression => {
+            let paramsCount = traverseContext.parameters.length;
+            traverseExpr(andExpression.expr, traverseContext, false);
+            if (where) {
+                const currentFragment = {
+                    fragment: andExpression.operator + ' ' + (0, select_columns_1.extractOriginalSql)(andExpression.expr),
+                    fields: [],
+                    dependOnFields: [],
+                    dependOnParams: [],
+                    parameters: [],
+                    dependOn: []
+                };
+                const paramsRight = (0, select_columns_1.getExpressions)(andExpression.expr, ts_mysql_parser_1.SimpleExprParamMarkerContext);
+                paramsRight.forEach(_ => {
+                    currentFragment.dependOnParams.push(paramsCount);
+                    paramsCount++;
+                });
+                const columnsRef = (0, select_columns_1.getExpressions)(andExpression.expr, ts_mysql_parser_1.ColumnRefContext);
+                columnsRef.forEach(colRef => {
+                    const fileName = (0, select_columns_1.splitName)(colRef.text);
+                    currentFragment.fields.push({
+                        field: fileName.name,
+                        name: fileName.name,
+                        table: fileName.prefix
+                    });
+                });
+                traverseContext.dynamicSqlInfo.where.push(currentFragment);
+            }
+        });
         return (0, collect_constraints_1.freshVar)(expr.text, 'tinyint');
     }
     throw Error('traverseExpr - not supported: ' + expr.text);
 }
-function traverseBoolPri(boolPri, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseBoolPri(boolPri, traverseContext, where = false) {
     if (boolPri instanceof ts_mysql_parser_1.PrimaryExprPredicateContext) {
         const predicate = boolPri.predicate();
-        const predicateType = traversePredicate(predicate, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const predicateType = traversePredicate(predicate, traverseContext, where);
         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, '?');
+        traverseBoolPri(boolPri2, traverseContext);
+        return (0, collect_constraints_1.freshVar)(boolPri.text, 'tinyint');
     }
     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({
+        // let paramsCount = traverseContext.parameters.length;
+        const typeLeft = traverseBoolPri(compareLeft, traverseContext);
+        const typeRight = traversePredicate(compareRight, traverseContext);
+        traverseContext.constraints.push({
             expression: boolPri.text,
             type1: typeLeft,
             type2: typeRight
@@ -658,9 +815,9 @@ function traverseBoolPri(boolPri, constraints, parameters, dbSchema, withSchema,
     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({
+        const typeLeft = traverseBoolPri(compareLeft, traverseContext);
+        const subQueryResult = traverseSubquery(compareRight, traverseContext);
+        traverseContext.constraints.push({
             expression: boolPri.text,
             type1: typeLeft,
             type2: {
@@ -672,15 +829,15 @@ function traverseBoolPri(boolPri, constraints, parameters, dbSchema, withSchema,
     }
     throw Error('traverseExpr - not supported: ' + boolPri.constructor.name);
 }
-function traversePredicate(predicate, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traversePredicate(predicate, traverseContext, where = false) {
     const bitExpr = predicate.bitExpr()[0]; //TODO - predicate length = 2? [1] == predicateOperations
-    const bitExprType = traverseBitExpr(bitExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+    const bitExprType = traverseBitExpr(bitExpr, traverseContext, where);
     const predicateOperations = predicate.predicateOperations();
     if (predicateOperations) {
-        const rightType = traversePredicateOperations(predicateOperations, bitExprType, constraints, parameters, fromColumns, dbSchema, withSchema);
+        const rightType = traversePredicateOperations(predicateOperations, bitExprType, traverseContext);
         if (bitExprType.kind == 'TypeOperator' && rightType.kind == 'TypeOperator') {
             rightType.types.forEach((t, i) => {
-                constraints.push({
+                traverseContext.constraints.push({
                     expression: predicateOperations.text,
                     type1: t,
                     type2: bitExprType.types[i],
@@ -690,7 +847,7 @@ function traversePredicate(predicate, constraints, parameters, dbSchema, withSch
         }
         if (bitExprType.kind == 'TypeVar' && rightType.kind == 'TypeOperator') {
             rightType.types.forEach((t, i) => {
-                constraints.push({
+                traverseContext.constraints.push({
                     expression: predicateOperations.text,
                     type1: bitExprType,
                     type2: Object.assign(Object.assign({}, t), { list: true }),
@@ -703,9 +860,9 @@ function traversePredicate(predicate, constraints, parameters, dbSchema, withSch
     }
     return bitExprType;
 }
-function traverseExprList(exprList, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseExprList(exprList, traverseContext) {
     const listType = exprList.expr().map(item => {
-        const exprType = traverseExpr(item, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const exprType = traverseExpr(item, traverseContext);
         return exprType;
     });
     const type = {
@@ -714,18 +871,18 @@ function traverseExprList(exprList, constraints, parameters, dbSchema, withSchem
     };
     return type;
 }
-function traverseBitExpr(bitExpr, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseBitExpr(bitExpr, traverseContext, where = false) {
     const simpleExpr = bitExpr.simpleExpr();
     if (simpleExpr) {
-        return traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return traverseSimpleExpr(simpleExpr, traverseContext, where);
     }
     if (bitExpr.bitExpr().length == 2) {
         const bitExprLeft = bitExpr.bitExpr()[0];
-        const typeLeftTemp = traverseBitExpr(bitExprLeft, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const typeLeftTemp = traverseBitExpr(bitExprLeft, traverseContext);
         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);
+        const typeRightTemp = traverseBitExpr(bitExprRight, traverseContext);
         //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;
@@ -734,35 +891,35 @@ function traverseBitExpr(bitExpr, constraints, parameters, dbSchema, withSchema,
             bitExprType.table = typeLeftTemp.table;
         }
         //PRECISA?
-        // constraints.push({
+        // traverseContext.constraints.push({
         //     expression: bitExpr.text,
         //     type1: typeLeft,
         //     type2: typeRight,
         //     mostGeneralType: true,
         //     coercionType: 'Sum'
         // })
-        // constraints.push({
+        // traverseContext.constraints.push({
         //     expression: bitExpr.text,
         //     type1: typeLeft,
         //     type2: typeRight,
         //     mostGeneralType: true,
         //     coercionType: 'Sum'
         // })
-        // constraints.push({
+        // traverseContext.constraints.push({
         //     expression: bitExpr.text,
         //     type1: bitExprType,
         //     type2: typeRight,
         //     mostGeneralType: true,
         //     coercionType: 'Sum'
         // })
-        constraints.push({
+        traverseContext.constraints.push({
             expression: bitExprLeft.text,
             type1: bitExprType,
             type2: typeLeft,
             mostGeneralType: true,
             coercionType: 'Sum'
         });
-        constraints.push({
+        traverseContext.constraints.push({
             expression: bitExprRight.text,
             type1: bitExprType,
             type2: typeRight,
@@ -770,7 +927,7 @@ function traverseBitExpr(bitExpr, constraints, parameters, dbSchema, withSchema,
             coercionType: 'Sum'
         });
         // const resultType = freshVar(bitExprRight.text, 'number');
-        // constraints.push({
+        // traverseContext.constraints.push({
         //     expression: bitExprRight.text,
         //     type1: resultType,
         //     type2: freshVar(bitExprRight.text, 'number'),
@@ -781,10 +938,10 @@ function traverseBitExpr(bitExpr, constraints, parameters, dbSchema, withSchema,
     }
     if (bitExpr.INTERVAL_SYMBOL()) {
         const bitExpr2 = bitExpr.bitExpr()[0];
-        const leftType = traverseBitExpr(bitExpr2, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const leftType = traverseBitExpr(bitExpr2, traverseContext);
         const expr = bitExpr.expr(); //expr interval
-        traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
-        constraints.push({
+        traverseExpr(expr, traverseContext);
+        traverseContext.constraints.push({
             expression: bitExpr.text,
             type1: leftType,
             type2: (0, collect_constraints_1.freshVar)('datetime', 'datetime')
@@ -793,23 +950,23 @@ function traverseBitExpr(bitExpr, constraints, parameters, dbSchema, withSchema,
     }
     throw Error('traverseBitExpr - not supported: ' + bitExpr.constructor.name);
 }
-function traversePredicateOperations(predicateOperations, parentType, constraints, parameters, fromColumns, dbSchema, withSchema) {
+function traversePredicateOperations(predicateOperations, parentType, traverseContext) {
     if (predicateOperations instanceof ts_mysql_parser_1.PredicateExprInContext) {
         const subquery = predicateOperations.subquery();
         if (subquery) {
-            const subQueryResult = traverseSubquery(subquery, constraints, parameters, dbSchema, withSchema, fromColumns);
+            const subQueryResult = traverseSubquery(subquery, traverseContext);
             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);
+            const rightType = traverseExprList(exprList, traverseContext);
             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({
+        const rightType = traverseSimpleExpr(simpleExpr, traverseContext);
+        traverseContext.constraints.push({
             expression: simpleExpr.text,
             type1: parentType,
             type2: rightType
@@ -819,19 +976,19 @@ function traversePredicateOperations(predicateOperations, parentType, constraint
     if (predicateOperations instanceof ts_mysql_parser_1.PredicateExprBetweenContext) {
         const bitExpr = predicateOperations.bitExpr();
         const predicate = predicateOperations.predicate();
-        const bitExprType = traverseBitExpr(bitExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
-        const predicateType = traversePredicate(predicate, constraints, parameters, dbSchema, withSchema, fromColumns);
-        constraints.push({
+        const bitExprType = traverseBitExpr(bitExpr, traverseContext);
+        const predicateType = traversePredicate(predicate, traverseContext);
+        traverseContext.constraints.push({
             expression: predicateOperations.text,
             type1: parentType,
             type2: bitExprType
         });
-        constraints.push({
+        traverseContext.constraints.push({
             expression: predicateOperations.text,
             type1: parentType,
             type2: predicateType
         });
-        constraints.push({
+        traverseContext.constraints.push({
             expression: predicateOperations.text,
             type1: bitExprType,
             type2: predicateType
@@ -840,13 +997,13 @@ function traversePredicateOperations(predicateOperations, parentType, constraint
     }
     throw Error("Not supported: " + predicateOperations.constructor.name);
 }
-function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseSimpleExpr(simpleExpr, traverseContext, where = false) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
     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);
+        const column = (0, select_columns_1.findColumn)(fieldName, traverseContext.fromColumns);
         const typeVar = (0, collect_constraints_1.freshVar)(column.columnName, column.columnType.type, column.tableAlias || column.table);
-        constraints.push({
+        traverseContext.constraints.push({
             expression: simpleExpr.text,
             type1: typeVar,
             type2: column.columnType,
@@ -856,7 +1013,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
     }
     if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprParamMarkerContext) {
         const param = (0, collect_constraints_1.freshVar)('?', '?');
-        parameters.push(param);
+        traverseContext.parameters.push(param);
         return param;
     }
     if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprLiteralContext) {
@@ -897,7 +1054,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
     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);
+            const exprType = traverseExpr(item, traverseContext, false);
             return exprType;
         });
         const resultType = {
@@ -908,7 +1065,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
     }
     if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprSubQueryContext) {
         const subquery = simpleExpr.subquery();
-        const subqueryResult = traverseSubquery(subquery, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const subqueryResult = traverseSubquery(subquery, traverseContext);
         return {
             kind: 'TypeOperator',
             types: subqueryResult.columns.map(t => (Object.assign(Object.assign({}, t.type), { table: '' })))
@@ -919,8 +1076,8 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         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({
+            const whenType = traverseExpr(whenExpr, traverseContext);
+            traverseContext.constraints.push({
                 expression: whenExpr.text,
                 type1: whenType.kind == 'TypeOperator' ? whenType.types[0] : whenType,
                 type2: (0, collect_constraints_1.freshVar)('tinyint', 'tinyint') //bool
@@ -928,8 +1085,8 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         });
         const thenTypes = simpleExpr.thenExpression().map(thenExprCtx => {
             const thenExpr = thenExprCtx.expr();
-            const thenType = traverseExpr(thenExpr, constraints, parameters, dbSchema, withSchema, fromColumns);
-            constraints.push({
+            const thenType = traverseExpr(thenExpr, traverseContext);
+            traverseContext.constraints.push({
                 expression: thenExprCtx.text,
                 type1: caseType,
                 type2: thenType.kind == 'TypeOperator' ? thenType.types[0] : thenType,
@@ -939,8 +1096,8 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         });
         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({
+            const elseType = traverseExpr(elseExpr, traverseContext);
+            traverseContext.constraints.push({
                 expression: (_c = simpleExpr.elseExpression()) === null || _c === void 0 ? void 0 : _c.text,
                 type1: caseType,
                 type2: elseType.kind == 'TypeOperator' ? elseType.types[0] : elseType,
@@ -948,7 +1105,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             });
             thenTypes.forEach(thenType => {
                 var _a;
-                constraints.push({
+                traverseContext.constraints.push({
                     expression: (_a = simpleExpr.elseExpression()) === null || _a === void 0 ? void 0 : _a.text,
                     type1: thenType,
                     type2: elseType.kind == 'TypeOperator' ? elseType.types[0] : elseType,
@@ -962,9 +1119,9 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         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({
+        const typeLeft = traverseExpr(exprLeft, traverseContext);
+        const typeRight = traverseExpr(exprRight, traverseContext);
+        traverseContext.constraints.push({
             expression: exprLeft.text,
             type1: typeLeft,
             type2: (0, collect_constraints_1.freshVar)('bigint', 'bigint')
@@ -972,7 +1129,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         if (typeRight.kind == 'TypeVar' && ((0, collect_constraints_1.isDateLiteral)(typeRight.name) || (0, collect_constraints_1.isDateTimeLiteral)(typeRight.name))) {
             typeRight.type = 'datetime';
         }
-        constraints.push({
+        traverseContext.constraints.push({
             expression: exprRight.text,
             type1: typeRight,
             type2: (0, collect_constraints_1.freshVar)('datetime', 'datetime')
@@ -985,8 +1142,8 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             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({
+                const inSumExprType = traverseExpr(inSumExpr, traverseContext);
+                traverseContext.constraints.push({
                     expression: simpleExpr.text,
                     type1: functionType,
                     type2: inSumExprType,
@@ -999,7 +1156,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             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);
+                traverseExpr(inSumExpr, traverseContext);
             }
             return functionType;
         }
@@ -1007,8 +1164,8 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             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({
+                const inSumExprType = traverseExpr(inSumExpr, traverseContext);
+                traverseContext.constraints.push({
                     expression: simpleExpr.text,
                     type1: functionType,
                     type2: inSumExprType,
@@ -1025,7 +1182,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             const exprList = sumExpr.exprList();
             if (exprList) {
                 exprList.expr().map(item => {
-                    const exprType = traverseExpr(item, constraints, parameters, dbSchema, withSchema, fromColumns);
+                    const exprType = traverseExpr(item, traverseContext);
                     return exprType;
                 });
                 /*
@@ -1053,8 +1210,8 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         if (runtimeFunctionCall.REPLACE_SYMBOL()) {
             const exprList = runtimeFunctionCall.expr();
             exprList.forEach(expr => {
-                const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
-                constraints.push({
+                const exprType = traverseExpr(expr, traverseContext);
+                traverseContext.constraints.push({
                     expression: expr.text,
                     type1: exprType,
                     type2: (0, collect_constraints_1.freshVar)('varchar', 'varchar')
@@ -1065,14 +1222,14 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         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);
+                const paramType = traverseExpr(expr, traverseContext);
                 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({
+                traverseContext.constraints.push({
                     expression: expr.text,
                     type1: paramType,
                     type2: (0, collect_constraints_1.freshVar)(simpleExpr.text, 'date')
@@ -1084,14 +1241,14 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         if (runtimeFunctionCall.DATE_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);
+                const paramType = traverseExpr(expr, traverseContext);
                 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({
+                traverseContext.constraints.push({
                     expression: expr.text,
                     type1: paramType,
                     type2: (0, collect_constraints_1.freshVar)(simpleExpr.text, 'date')
@@ -1102,7 +1259,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         if (runtimeFunctionCall.HOUR_SYMBOL() || runtimeFunctionCall.MINUTE_SYMBOL() || runtimeFunctionCall.SECOND_SYMBOL()) {
             const expr = (_j = runtimeFunctionCall.exprWithParentheses()) === null || _j === void 0 ? void 0 : _j.expr();
             if (expr) {
-                const paramType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+                const paramType = traverseExpr(expr, traverseContext);
                 if (paramType.kind == 'TypeVar' && (0, collect_constraints_1.isTimeLiteral)(paramType.name)) {
                     paramType.type = 'time';
                 }
@@ -1112,7 +1269,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 if (paramType.kind == 'TypeVar' && (0, collect_constraints_1.isDateTimeLiteral)(paramType.name)) {
                     paramType.type = 'datetime';
                 }
-                constraints.push({
+                traverseContext.constraints.push({
                     expression: expr.text,
                     type1: paramType,
                     type2: (0, collect_constraints_1.freshVar)(simpleExpr.text, 'time')
@@ -1127,22 +1284,22 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         if (trimFunction) {
             const exprList = trimFunction.expr();
             if (exprList.length == 1) {
-                const exprType = traverseExpr(exprList[0], constraints, parameters, dbSchema, withSchema, fromColumns);
-                constraints.push({
+                const exprType = traverseExpr(exprList[0], traverseContext);
+                traverseContext.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({
+                const exprType = traverseExpr(exprList[0], traverseContext);
+                const expr2Type = traverseExpr(exprList[1], traverseContext);
+                traverseContext.constraints.push({
                     expression: exprList[0].text,
                     type1: exprType,
                     type2: (0, collect_constraints_1.freshVar)('varchar', 'varchar')
                 });
-                constraints.push({
+                traverseContext.constraints.push({
                     expression: exprList[1].text,
                     type1: expr2Type,
                     type2: (0, collect_constraints_1.freshVar)('varchar', 'varchar')
@@ -1159,7 +1316,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 kind: 'FixedLengthParams',
                 paramsType: [varcharParam, intParam, intParam]
             };
-            traverseExprListParameters(exprList, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            traverseExprListParameters(exprList, params, traverseContext);
             return varcharParam;
         }
         if (runtimeFunctionCall.ADDDATE_SYMBOL()
@@ -1170,17 +1327,17 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             //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);
+            const typeExpr1 = traverseExpr(expr1, traverseContext);
+            const typeExpr2 = traverseExpr(expr2, traverseContext);
             if (typeExpr1.kind == 'TypeVar' && ((0, collect_constraints_1.isDateLiteral)(typeExpr1.name) || (0, collect_constraints_1.isDateTimeLiteral)(typeExpr1.name))) {
                 typeExpr1.type = 'datetime';
             }
-            constraints.push({
+            traverseContext.constraints.push({
                 expression: expr1.text,
                 type1: typeExpr1,
                 type2: (0, collect_constraints_1.freshVar)('datetime', 'datetime')
             });
-            constraints.push({
+            traverseContext.constraints.push({
                 expression: expr2.text,
                 type1: typeExpr2,
                 type2: (0, collect_constraints_1.freshVar)('bigint', 'bigint')
@@ -1195,9 +1352,9 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                     kind: 'VariableLengthParams',
                     paramType: '?'
                 };
-                const paramsTypeList = traverseExprListParameters(exprList, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+                const paramsTypeList = traverseExprListParameters(exprList, params, traverseContext);
                 paramsTypeList.forEach((typeVar, paramIndex) => {
-                    constraints.push({
+                    traverseContext.constraints.push({
                         expression: runtimeFunctionCall.text + '_param' + (paramIndex + 1),
                         type1: paramType,
                         type2: typeVar,
@@ -1212,29 +1369,29 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
         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({
+            const param1 = traverseExpr(exprList[0], traverseContext);
+            const param2 = traverseExpr(exprList[1], traverseContext);
+            traverseContext.constraints.push({
                 expression: simpleExpr.text,
                 type1: (0, collect_constraints_1.freshVar)('number', 'number'),
                 type2: param1,
                 mostGeneralType: true,
                 coercionType: 'Numeric'
             });
-            constraints.push({
+            traverseContext.constraints.push({
                 expression: simpleExpr.text,
                 type1: (0, collect_constraints_1.freshVar)('number', 'number'),
                 type2: param2,
                 mostGeneralType: true,
                 coercionType: 'Numeric'
             });
-            constraints.push({
+            traverseContext.constraints.push({
                 expression: simpleExpr.text,
                 type1: functionType,
                 type2: param1,
                 mostGeneralType: true
             });
-            constraints.push({
+            traverseContext.constraints.push({
                 expression: simpleExpr.text,
                 type1: functionType,
                 type2: param2,
@@ -1247,10 +1404,10 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             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({
+            traverseExpr(expr1, traverseContext);
+            const expr2Type = traverseExpr(expr2, traverseContext);
+            const expr3Type = traverseExpr(expr3, traverseContext);
+            traverseContext.constraints.push({
                 expression: runtimeFunctionCall.text,
                 type1: expr2Type,
                 type2: expr3Type,
@@ -1268,12 +1425,12 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 kind: 'VariableLengthParams',
                 paramType: 'varchar'
             };
-            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            walkFunctionParameters(simpleExpr, params, traverseContext);
             return varcharType;
         }
         if (functionIdentifier === 'avg') {
             const functionType = (0, collect_constraints_1.freshVar)(simpleExpr.text, '?');
-            constraints.push({
+            traverseContext.constraints.push({
                 expression: simpleExpr.text,
                 type1: functionType,
                 type2: (0, collect_constraints_1.freshVar)('decimal', 'decimal'),
@@ -1283,7 +1440,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 kind: 'FixedLengthParams',
                 paramsType: [functionType]
             };
-            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            walkFunctionParameters(simpleExpr, params, traverseContext);
             return functionType;
         }
         if (functionIdentifier === 'round') {
@@ -1292,9 +1449,9 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 kind: 'FixedLengthParams',
                 paramsType: [functionType]
             };
-            const paramsType = walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            const paramsType = walkFunctionParameters(simpleExpr, params, traverseContext);
             //The return value has the same type as the first argument
-            constraints.push({
+            traverseContext.constraints.push({
                 expression: simpleExpr.text,
                 type1: functionType,
                 type2: paramsType[0],
@@ -1308,7 +1465,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 kind: 'FixedLengthParams',
                 paramsType: [doubleParam, doubleParam]
             };
-            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            walkFunctionParameters(simpleExpr, params, traverseContext);
             return (0, collect_constraints_1.freshVar)(simpleExpr.text, 'bigint');
         }
         if (functionIdentifier === 'str_to_date') {
@@ -1317,7 +1474,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 kind: 'FixedLengthParams',
                 paramsType: [varcharParam, varcharParam]
             };
-            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            walkFunctionParameters(simpleExpr, params, traverseContext);
             return (0, collect_constraints_1.freshVar)(simpleExpr.text, 'date');
         }
         if (functionIdentifier === 'datediff') {
@@ -1325,9 +1482,9 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             if (udfExprList) {
                 udfExprList.forEach((inExpr) => {
                     const expr = inExpr.expr();
-                    const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+                    const exprType = traverseExpr(expr, traverseContext);
                     const newType = (0, collect_constraints_1.verifyDateTypesCoercion)(exprType);
-                    constraints.push({
+                    traverseContext.constraints.push({
                         expression: expr.text,
                         type1: newType,
                         type2: (0, collect_constraints_1.freshVar)('date', 'date'),
@@ -1342,8 +1499,8 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             if (udfExprList) {
                 udfExprList.forEach((inExpr) => {
                     const expr = inExpr.expr();
-                    const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
-                    constraints.push({
+                    const exprType = traverseExpr(expr, traverseContext);
+                    traverseContext.constraints.push({
                         expression: expr.text,
                         type1: exprType,
                         type2: (0, collect_constraints_1.freshVar)('bigint', 'bigint'),
@@ -1360,7 +1517,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 kind: 'FixedLengthParams',
                 paramsType: [varcharParam, intParam, varcharParam]
             };
-            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            walkFunctionParameters(simpleExpr, params, traverseContext);
             return varcharParam;
         }
         if (functionIdentifier === 'lower'
@@ -1375,7 +1532,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 kind: 'FixedLengthParams',
                 paramsType: [varcharParam]
             };
-            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            walkFunctionParameters(simpleExpr, params, traverseContext);
             return varcharParam;
         }
         if (functionIdentifier === 'length' || functionIdentifier == 'char_length') {
@@ -1384,15 +1541,15 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 kind: 'FixedLengthParams',
                 paramsType: [varcharParam]
             };
-            walkFunctionParameters(simpleExpr, params, constraints, parameters, dbSchema, withSchema, fromColumns);
+            walkFunctionParameters(simpleExpr, params, traverseContext);
             return (0, collect_constraints_1.freshVar)('int', 'int');
         }
         if (functionIdentifier === 'abs') {
             const functionType = (0, collect_constraints_1.freshVar)('number', 'number');
             const udfExprList = (_o = simpleExpr.functionCall().udfExprList()) === null || _o === void 0 ? void 0 : _o.udfExpr();
             udfExprList === null || udfExprList === void 0 ? void 0 : udfExprList.forEach(expr => {
-                const param1 = traverseExpr(expr.expr(), constraints, parameters, dbSchema, withSchema, fromColumns);
-                constraints.push({
+                const param1 = traverseExpr(expr.expr(), traverseContext);
+                traverseContext.constraints.push({
                     expression: simpleExpr.text,
                     type1: functionType,
                     type2: param1,
@@ -1406,8 +1563,8 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             const functionType = (0, collect_constraints_1.freshVar)('number', 'number');
             const udfExprList = (_p = simpleExpr.functionCall().udfExprList()) === null || _p === void 0 ? void 0 : _p.udfExpr();
             udfExprList === null || udfExprList === void 0 ? void 0 : udfExprList.forEach(expr => {
-                const param1 = traverseExpr(expr.expr(), constraints, parameters, dbSchema, withSchema, fromColumns);
-                constraints.push({
+                const param1 = traverseExpr(expr.expr(), traverseContext);
+                traverseContext.constraints.push({
                     expression: simpleExpr.text,
                     type1: functionType,
                     type2: param1,
@@ -1424,10 +1581,10 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
                 const unit = first.text.trim().toLowerCase();
                 rest.forEach((inExpr, paramIndex) => {
                     const expr = inExpr.expr();
-                    const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+                    const exprType = traverseExpr(expr, traverseContext);
                     const newType = (0, collect_constraints_1.verifyDateTypesCoercion)(exprType);
                     //const expectedType = ['hour', 'minute', 'second'].includes(unit)? 'time' : 'datetime'
-                    constraints.push({
+                    traverseContext.constraints.push({
                         expression: expr.text,
                         type1: newType,
                         type2: (0, collect_constraints_1.freshVar)('datetime', 'datetime'),
@@ -1442,14 +1599,14 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             const udfExprList = (_r = simpleExpr.functionCall().udfExprList()) === null || _r === void 0 ? void 0 : _r.udfExpr();
             if (udfExprList) {
                 const [expr1, expr2] = udfExprList;
-                const expr1Type = traverseExpr(expr1.expr(), constraints, parameters, dbSchema, withSchema, fromColumns);
-                constraints.push({
+                const expr1Type = traverseExpr(expr1.expr(), traverseContext);
+                traverseContext.constraints.push({
                     expression: expr1.text,
                     type1: functionType,
                     type2: expr1Type
                 });
-                const expr2Type = traverseExpr(expr2.expr(), constraints, parameters, dbSchema, withSchema, fromColumns);
-                constraints.push({
+                const expr2Type = traverseExpr(expr2.expr(), traverseContext);
+                traverseContext.constraints.push({
                     expression: expr2.text,
                     type1: functionType,
                     type2: expr2Type
@@ -1464,8 +1621,8 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
             const udfExprList = (_s = simpleExpr.functionCall().udfExprList()) === null || _s === void 0 ? void 0 : _s.udfExpr();
             if (udfExprList) {
                 const [expr1] = udfExprList;
-                const paramType = traverseExpr(expr1.expr(), constraints, parameters, dbSchema, withSchema, fromColumns);
-                constraints.push({
+                const paramType = traverseExpr(expr1.expr(), traverseContext);
+                traverseContext.constraints.push({
                     expression: expr1.text,
                     type1: paramType,
                     type2: (0, collect_constraints_1.freshVar)(expr1.text, 'varchar')
@@ -1477,7 +1634,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
     }
     if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprWindowingFunctionContext) {
         const windowFunctionCall = simpleExpr.windowFunctionCall();
-        return traverseWindowFunctionCall(windowFunctionCall, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return traverseWindowFunctionCall(windowFunctionCall, traverseContext);
     }
     if (simpleExpr instanceof ts_mysql_parser_1.SimpleExprCastContext) {
         const castType = simpleExpr.castType();
@@ -1487,7 +1644,7 @@ function traverseSimpleExpr(simpleExpr, constraints, parameters, dbSchema, withS
     }
     throw Error('traverseSimpleExpr - not supported: ' + simpleExpr.constructor.name);
 }
-function traverseWindowFunctionCall(windowFunctionCall, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseWindowFunctionCall(windowFunctionCall, traverseContext) {
     if (windowFunctionCall.ROW_NUMBER_SYMBOL()
         || windowFunctionCall.RANK_SYMBOL()
         || windowFunctionCall.DENSE_RANK_SYMBOL()
@@ -1497,20 +1654,20 @@ function traverseWindowFunctionCall(windowFunctionCall, constraints, parameters,
     }
     const expr = windowFunctionCall.expr();
     if (expr) {
-        return traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return traverseExpr(expr, traverseContext);
     }
     const exprWithParentheses = windowFunctionCall.exprWithParentheses();
     if (exprWithParentheses) {
         const expr = exprWithParentheses.expr();
-        return traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+        return traverseExpr(expr, traverseContext);
     }
     throw Error('No support for expression' + windowFunctionCall.constructor.name);
 }
-function traverseExprListParameters(exprList, params, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function traverseExprListParameters(exprList, params, traverseContext) {
     return exprList.map((expr, paramIndex) => {
-        const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
+        const exprType = traverseExpr(expr, traverseContext);
         const paramType = params.kind == 'FixedLengthParams' ? params.paramsType[paramIndex] : (0, collect_constraints_1.freshVar)(params.paramType, params.paramType);
-        constraints.push({
+        traverseContext.constraints.push({
             expression: expr.text,
             type1: exprType,
             type2: paramType,
@@ -1519,7 +1676,7 @@ function traverseExprListParameters(exprList, params, constraints, parameters, d
         return paramType;
     });
 }
-function walkFunctionParameters(simpleExprFunction, params, constraints, parameters, dbSchema, withSchema, fromColumns) {
+function walkFunctionParameters(simpleExprFunction, params, traverseContext) {
     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();
@@ -1530,8 +1687,8 @@ function walkFunctionParameters(simpleExprFunction, params, constraints, paramet
         })
             .map((inExpr, paramIndex) => {
             const expr = inExpr.expr();
-            const exprType = traverseExpr(expr, constraints, parameters, dbSchema, withSchema, fromColumns);
-            constraints.push({
+            const exprType = traverseExpr(expr, traverseContext);
+            traverseContext.constraints.push({
                 expression: expr.text,
                 type1: exprType,
                 type2: params.kind == 'FixedLengthParams' ? params.paramsType[paramIndex] : (0, collect_constraints_1.freshVar)(params.paramType, params.paramType),
@@ -1543,8 +1700,8 @@ function walkFunctionParameters(simpleExprFunction, params, constraints, paramet
     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({
+            const inSumExprType = traverseExpr(inExpr, traverseContext);
+            traverseContext.constraints.push({
                 expression: inExpr.text,
                 type1: params.kind == 'FixedLengthParams' ? params.paramsType[paramIndex] : (0, collect_constraints_1.freshVar)(params.paramType, params.paramType),
                 type2: inSumExprType,