@elyx-code/editor-ui 0.0.2

package/src/services/database/utils.ts

@@ -0,0 +1,1301 @@
+import {
+	BUILT_IN_BASE_ENTITY_IDS,
+	DefinitionEntityState,
+	DataTypeState,
+	EntityType,
+	getDatabaseEntities,
+	PrimitiveTypes,
+	isObject,
+	searchStatementDefs,
+	searchStatementFunctions
+} from '@elyx-code/project-logic-tree';
+import { IJoinQuery, IOrderQuery, IWhereQuery } from 'jsstore';
+import {
+	Column,
+	Database,
+	ISelectQueryResult,
+	Table
+} from '../local-relational-database';
+import { resolveColumnTypeFromDataTypeEntity } from '../local-relational-database/utils';
+import { TableColumnType } from '../../lib/table/types';
+import { EditorService } from '../editor';
+import {
+	SQLAST as SQLASTLib,
+	searchStatementState as searchStatementStateLib,
+	searchStatementUtils
+} from '@elyx-code/project-logic-tree';
+import { isEmpty } from '../../utils';
+
+const { ColumnRef } = searchStatementStateLib;
+const { SearchLiteralValueType, SearchStatementNodeType } = searchStatementDefs;
+const { getFunctionDefinition } = searchStatementFunctions;
+
+type ColumnRef = searchStatementStateLib.ColumnRef;
+type FunctionCall = searchStatementStateLib.FunctionCall;
+type SearchLiteralValueType = searchStatementDefs.SearchLiteralValueType;
+
+type SelectStmt = SQLASTLib.SelectStmt;
+type JoinExpr = SQLASTLib.JoinExpr;
+type OrderByClause = SQLASTLib.OrderByClause;
+type SortSpecification = SQLASTLib.SortSpecification;
+type Keyword<T extends string = string> = SQLASTLib.Keyword<T>;
+type SelectClause = SQLASTLib.SelectClause;
+type WhereClause = SQLASTLib.WhereClause;
+type Expr = SQLASTLib.Expr;
+type PostgresqlOperatorExpr = SQLASTLib.PostgresqlOperatorExpr;
+
+export function fromColumnMappingsToJsStore(
+	columnMappings: (
+		| searchStatementUtils.IShallowColumnMapping
+		| searchStatementUtils.IColumnMapping
+	)[]
+): {
+	[columnName: string]: string;
+} {
+	return columnMappings.reduce(
+		(acc, columnMapping) => {
+			acc[
+				(columnMapping as searchStatementUtils.IColumnMapping).column
+					?.columnName ||
+					(
+						columnMapping as searchStatementUtils.IShallowColumnMapping
+					).from
+			] =
+				(columnMapping as searchStatementUtils.IColumnMapping).as ||
+				(columnMapping as searchStatementUtils.IShallowColumnMapping)
+					.to;
+
+			return acc;
+		},
+		{} as { [columnName: string]: string }
+	);
+}
+
+export function fromColumnRefToTableColumnType(
+	column: ColumnRef | FunctionCall
+): TableColumnType {
+	if (column.type === SearchStatementNodeType.FunctionCall) {
+		const fc = column as FunctionCall;
+		const def = fc.functionName
+			? getFunctionDefinition(fc.functionName)
+			: null;
+		if (def) {
+			switch (def.returnType) {
+				case 'string':
+					return TableColumnType.String;
+				case 'number':
+					return TableColumnType.Number;
+				case 'boolean':
+					return TableColumnType.Boolean;
+				case 'date':
+					return TableColumnType.Date;
+				default:
+					return TableColumnType.String;
+			}
+		}
+		return TableColumnType.String;
+	}
+
+	const col = column as ColumnRef;
+	if (!!col.property) {
+		const dataType: DataTypeState = col.property?.dataType;
+
+		if (!dataType) {
+			return TableColumnType.String;
+		}
+
+		if (!dataType.entity) {
+			return TableColumnType.String;
+		}
+
+		// If the 'entity' of the data type is of type primitive entity,
+		// then map to primitive types
+		// Otherwise, it is a foreign key reference to an entity, so we map to string
+		if (dataType.entity?.type === EntityType.PrimitiveEntity) {
+			switch (dataType.entity.name) {
+				case PrimitiveTypes.String:
+					return TableColumnType.String;
+				case PrimitiveTypes.Number:
+					return TableColumnType.Number;
+				case PrimitiveTypes.Boolean:
+					return TableColumnType.Boolean;
+				case PrimitiveTypes.Date:
+					return TableColumnType.Date;
+				case PrimitiveTypes.UUID:
+					return TableColumnType.UUID;
+				default:
+					return TableColumnType.String;
+			}
+		} else if (dataType.entity?.type === EntityType.DefinitionEntity) {
+			return TableColumnType.Relation;
+		}
+
+		return TableColumnType.String;
+	} else if (!!col.literalValue) {
+		switch (col.literalValue.valueType) {
+			case SearchLiteralValueType.String:
+				return TableColumnType.String;
+			case SearchLiteralValueType.Number:
+				return TableColumnType.Number;
+			case SearchLiteralValueType.Date:
+				return TableColumnType.Date;
+			case SearchLiteralValueType.Boolean:
+				return TableColumnType.Boolean;
+			case SearchLiteralValueType.Null:
+				return TableColumnType.String;
+			default:
+				return TableColumnType.String;
+		}
+	}
+	return TableColumnType.String;
+}
+
+enum ResolvedOperator {
+	And = 'and',
+	Or = 'or',
+	Like = 'like',
+	Not = 'not',
+	In = 'in',
+	Equal = '=',
+	Between = '-',
+	BiggerThan = '>',
+	SmallerThan = '<',
+	BiggerThanOrEqualTo = '>=',
+	SmallerThanOrEqualTo = '<=',
+	NotEqual = '!='
+}
+
+export function resolveJsstoreOperatorCharacterFromAstOperator(
+	operator: searchStatementUtils.SupportedOperators
+): ResolvedOperator | null {
+	let resolvedOperator: ResolvedOperator = null;
+
+	if (typeof operator === 'string') {
+		// For simple operators like '=', '>', '<', '<=', etc.
+		resolvedOperator = operator as ResolvedOperator;
+	} else if (Array.isArray(operator)) {
+		// For operators like 'IS NOT' or 'IS DISTINCT FROM', etc.
+		const [first, second, third, fourth] = operator;
+		const resolvedFirst = resolveJsstoreOperatorCharacterFromAstOperator(
+			first as searchStatementUtils.SupportedOperators
+		);
+
+		if (resolvedFirst === '=') {
+			resolvedOperator = ResolvedOperator.Equal;
+		} else {
+			resolvedOperator = resolvedFirst as ResolvedOperator;
+		}
+
+		if (second) {
+			const resolvedSecond =
+				resolveJsstoreOperatorCharacterFromAstOperator(
+					second as searchStatementUtils.SupportedOperators
+				);
+
+			if (
+				resolvedFirst === ResolvedOperator.Equal &&
+				resolvedSecond === ResolvedOperator.Not
+			) {
+				resolvedOperator = ResolvedOperator.NotEqual;
+			} else {
+				resolvedOperator = (resolvedSecond +
+					resolvedOperator) as ResolvedOperator;
+			}
+		}
+
+		// if (third) {
+		// 	const resolvedThird = resolveJsstoreOperatorCharacterFromAstOperator(
+		// 		third as Keyword<'DISTINCT'> | Keyword<'FROM'>
+		// 	);
+		// }
+	} else if (isObject(operator)) {
+		// For single keyword operators like 'IS', 'IN', 'LIKE', 'NOT', etc.
+		const resolvedKeywordOperator = (operator as Keyword).name;
+
+		const sanitizedKeywordOperator = resolvedKeywordOperator.toLowerCase();
+
+		switch (sanitizedKeywordOperator) {
+			case 'between': {
+				resolvedOperator = ResolvedOperator.Between;
+				break;
+			}
+			case 'is': {
+				resolvedOperator = ResolvedOperator.Equal;
+				break;
+			}
+			case 'not': {
+				resolvedOperator = ResolvedOperator.Not;
+				break;
+			}
+			default: {
+				resolvedOperator = sanitizedKeywordOperator as ResolvedOperator;
+				break;
+			}
+		}
+	}
+
+	return resolvedOperator;
+}
+
+export function fromWhereExprToJsStoreWhereObject(
+	whereExpr: Expr,
+	knownColumns: searchStatementUtils.IColumnMapping[]
+): IWhereQuery | null {
+	if (!whereExpr) {
+		return null;
+	}
+
+	/*
+		The Jsstore where object,
+		by default assumes any properties to be column names, and the values to be matched exactly for the condition to be met
+		All properties are assumed to be ANDed together
+
+		For 'or', a property called 'or' with a nested object of the same structure is used
+		For 'in', a property called 'in' with an array of values is used
+		For 'like', a property called 'like' with a literal string value is used such as 'like': '%value%'
+		For 'regex', a property called 'regex' with a JS regex value is used such as 'regex': /value/i
+		For 'between', a property called '-' with an object with exactly two properties 'low' and 'high' is used such as '-': { low: 0, high: 10 }
+		For any columns with date types, the value can be a JS Date object
+
+		For any common SQL operators, the where object can be passed properties which are the characters of the operator, for example '>': 10
+	*/
+	let whereObject: IWhereQuery & {
+		[key: string]: any;
+	} = {};
+
+	// The current condition is the "right" side of the expression
+	if (whereExpr.type === 'binary_expr') {
+		const left = whereExpr.left;
+		const right = whereExpr.right;
+		let leftVarName: string = '';
+		let rightVarName: string = '';
+		let leftLiteralValue!: string | number | null | boolean | Date;
+		let rightLiteralValue!: string | number | null | boolean | Date;
+		let previousSiblingObject: IWhereQuery | null = null;
+		let nestedObject: IWhereQuery | null = null;
+
+		const operator: ResolvedOperator | null =
+			resolveJsstoreOperatorCharacterFromAstOperator(
+				whereExpr.operator as searchStatementUtils.SupportedOperators
+			);
+
+		let objectKey: string = '';
+
+		if (left.type === 'member_expr') {
+			if (left.object.type === 'identifier') {
+				// leftVarName += left.object.text;
+			}
+
+			if (left.property.type === 'identifier') {
+				leftVarName += left.property.text;
+				// leftVarName += '.' + left.property.text;
+			}
+		} else if (left.type === 'identifier') {
+			leftVarName = left.text;
+		} else if (left.type === 'number_literal') {
+			leftLiteralValue = left.value;
+		} else if (left.type === 'string_literal') {
+			leftLiteralValue = left.value;
+		} else if (left.type === 'boolean_literal') {
+			leftLiteralValue = left.value;
+		} else if (left.type === 'null_literal') {
+			leftLiteralValue = left.value;
+			// } else if (left.type === 'paren_expr') {
+			// 	previousSiblingObject = fromWhereExprToJsStoreWhereObject(
+			// 		left.expr as Expr
+			// 	);
+		} else if (left.type === 'binary_expr') {
+			previousSiblingObject = fromWhereExprToJsStoreWhereObject(
+				left,
+				knownColumns
+			);
+		}
+
+		if (leftVarName === 'manager') {
+		}
+
+		if (right.type === 'member_expr') {
+			if (right.object.type === 'identifier') {
+				// rightVarName += right.object.text;
+			}
+
+			if (right.property.type === 'identifier') {
+				// rightVarName += '.' + right.property.text;
+				rightVarName += right.property.text;
+			}
+		} else if (right.type === 'identifier') {
+			rightVarName = right.text;
+		} else if (right.type === 'number_literal') {
+			rightLiteralValue = right.value;
+		} else if (right.type === 'string_literal') {
+			rightLiteralValue = right.value;
+		} else if (right.type === 'boolean_literal') {
+			rightLiteralValue = right.value;
+		} else if (right.type === 'null_literal') {
+			rightLiteralValue = right.value;
+		} else if (right.type === 'paren_expr') {
+			nestedObject = fromWhereExprToJsStoreWhereObject(
+				right.expr as Expr,
+				knownColumns
+			);
+		} else if (right.type === 'binary_expr') {
+			nestedObject = fromWhereExprToJsStoreWhereObject(
+				right,
+				knownColumns
+			);
+		}
+
+		// Sanitize value if needed, based on column type.
+		// E.g. if column is a date, the value should be a Date object
+		// If column is a number, the value should be a number, etc.
+		const foundColumn = knownColumns.find(
+			(column) => column.column.columnName === leftVarName
+		);
+
+		const columnType = foundColumn?.column.property?.dataType
+			? resolveColumnTypeFromDataTypeEntity(
+					foundColumn.column.property.dataType
+				)
+			: TableColumnType.String;
+
+		if (columnType === TableColumnType.Date) {
+			if (rightLiteralValue) {
+				rightLiteralValue = new Date(rightLiteralValue as string);
+			}
+			if (leftLiteralValue) {
+				leftLiteralValue = new Date(leftLiteralValue as string);
+			}
+		}
+
+		// Jsstore doens't take null as a value, so we need to convert it to the "empty" value of the type
+		if (rightLiteralValue === null) {
+			if (
+				columnType === TableColumnType.Date ||
+				columnType === TableColumnType.String ||
+				columnType === TableColumnType.Number ||
+				columnType === TableColumnType.UUID ||
+				columnType === TableColumnType.Relation ||
+				columnType === TableColumnType.Boolean
+			) {
+				// Padding literal null with empty string
+				rightLiteralValue = '';
+			}
+		}
+
+		if (!!operator) {
+			if (
+				operator === ResolvedOperator.And ||
+				operator === ResolvedOperator.Equal
+			) {
+				objectKey = leftVarName;
+
+				if (previousSiblingObject) {
+					whereObject = {
+						...previousSiblingObject,
+						...whereObject
+					};
+				}
+
+				if (nestedObject) {
+					whereObject = {
+						...whereObject,
+						...nestedObject
+					};
+				} else if (rightVarName) {
+					whereObject[objectKey] = rightVarName;
+				} else {
+					whereObject[objectKey] = rightLiteralValue;
+				}
+			} else if (operator === ResolvedOperator.Or) {
+				whereObject.or = {};
+
+				if (previousSiblingObject) {
+					whereObject = {
+						...previousSiblingObject,
+						...whereObject
+					};
+				}
+
+				objectKey = leftVarName;
+
+				if (nestedObject) {
+					whereObject.or = {
+						...whereObject.or,
+						...nestedObject
+					};
+				} else if (rightVarName) {
+					whereObject.or[objectKey] = rightVarName;
+				} else {
+					whereObject.or[objectKey] = rightLiteralValue;
+				}
+			} else if (operator === ResolvedOperator.Like) {
+				objectKey = leftVarName;
+
+				if (previousSiblingObject) {
+					whereObject = { ...previousSiblingObject, ...whereObject };
+				}
+
+				if (nestedObject) {
+					whereObject.like = {
+						...nestedObject
+					};
+				} else if (rightVarName) {
+					whereObject[objectKey] = {
+						like: rightVarName
+					};
+				} else {
+					whereObject[objectKey] = {
+						like: rightLiteralValue
+					};
+				}
+			} else if (['>', '<', '>=', '<=', '!='].includes(operator)) {
+				objectKey = leftVarName;
+
+				if (previousSiblingObject) {
+					whereObject = {
+						...previousSiblingObject,
+						...whereObject
+					};
+				}
+
+				if (nestedObject) {
+					whereObject[operator] = {
+						...(whereObject[operator] || {}),
+						...nestedObject
+					};
+				} else if (rightVarName) {
+					whereObject[objectKey] = {
+						[operator]: rightVarName
+					};
+				} else {
+					whereObject[objectKey] = {
+						[operator]: rightLiteralValue
+					};
+				}
+			} else if (operator === ResolvedOperator.In) {
+				objectKey = leftVarName;
+
+				if (previousSiblingObject) {
+					whereObject = {
+						...previousSiblingObject,
+						...whereObject
+					};
+				}
+
+				if (nestedObject) {
+					whereObject.in = {
+						...nestedObject
+					};
+				} else if (rightVarName) {
+					whereObject[objectKey] = {
+						in: rightVarName
+					};
+				} else {
+					whereObject[objectKey] = {
+						in: rightLiteralValue
+					};
+				}
+			} else if (operator === ResolvedOperator.Between) {
+				// TODO: implement between, currently it is treated like other operators
+				// but we should resolve the two values 'low' and 'high' and add them as keys in the object under the '-' (between) property
+				objectKey = leftVarName;
+
+				if (previousSiblingObject) {
+					whereObject = {
+						...previousSiblingObject,
+						...whereObject
+					};
+				}
+
+				if (nestedObject) {
+					whereObject[ResolvedOperator.Between] = {
+						...nestedObject
+					};
+				} else if (rightVarName) {
+					whereObject[objectKey] = {
+						[ResolvedOperator.Between]: rightVarName
+					};
+				} else {
+					whereObject[objectKey] = {
+						[ResolvedOperator.Between]: rightLiteralValue
+					};
+				}
+			}
+		}
+	}
+
+	return whereObject;
+}
+
+export function fromWhereClauseToJsStoreWhereObject(
+	whereClause: WhereClause,
+	knownColumns: searchStatementUtils.IColumnMapping[]
+): IWhereQuery | null {
+	if (!whereClause) {
+		return null;
+	}
+
+	/*
+		The Jsstore where object,
+		by default assumes any properties to be column names, and the values to be matched exactly for the condition to be met
+		All properties are assumed to be ANDed together
+
+		For 'or', a property called 'or' with a nested object of the same structure is used
+		For 'in', a property called 'in' with an array of values is used
+		For 'like', a property called 'like' with a literal string value is used such as 'like': '%value%'
+		For 'regex', a property called 'regex' with a JS regex value is used such as 'regex': /value/i
+		For 'between', a property called '-' with an object with exactly two properties 'low' and 'high' is used such as '-': { low: 0, high: 10 }
+		For any columns with date types, the value can be a JS Date object
+
+		For any common SQL operators, the where object can be passed properties which are the characters of the operator, for example '>': 10
+	*/
+	const whereObject: IWhereQuery & {
+		[key: string]: any;
+	} = fromWhereExprToJsStoreWhereObject(whereClause.expr, knownColumns);
+
+	return whereObject;
+}
+
+export async function fromOrderByClauseToJsStore(
+	orderByClause: OrderByClause,
+	parentQuery: SelectStmt,
+	helpers: {
+		onNestedSelect?: (
+			selectStatement: SelectStmt
+		) => ISelectQueryResult | Promise<ISelectQueryResult>;
+		onDescribeTable?: (tableName: string) => Promise<Table>;
+	} = {
+		onNestedSelect: () => ({
+			columns: [],
+			rows: [],
+			tableName: null,
+			entity: null,
+			total: 0
+		}),
+		onDescribeTable: () => null
+	}
+): Promise<IOrderQuery[]> {
+	const mainSource =
+		searchStatementUtils.getMainSourceFromSelectStatement(parentQuery);
+
+	return Promise.all(
+		(orderByClause.specifications.items as SortSpecification[]).map(
+			async (sortSpec) => {
+				let type: 'asc' | 'desc';
+
+				let fullKeyString: string = '';
+
+				if (sortSpec.direction?.type === 'sort_direction_asc') {
+					type = 'asc';
+				} else if (sortSpec.direction?.type === 'sort_direction_desc') {
+					type = 'desc';
+				} else {
+					type = 'asc';
+				}
+
+				if (sortSpec.expr.type === 'member_expr') {
+					if (sortSpec.expr.object.type === 'identifier') {
+						fullKeyString += sortSpec.expr.object.text;
+					}
+
+					if (sortSpec.expr.property.type === 'identifier') {
+						fullKeyString += '.' + sortSpec.expr.property.text;
+					}
+				} else if (sortSpec.expr.type === 'identifier') {
+					fullKeyString = sortSpec.expr.text;
+				}
+
+				const mainSelectHasJoins = await hasJoinsInSelectStatement(
+					parentQuery,
+					helpers
+				);
+
+				if (mainSource.type === 'table' && !mainSelectHasJoins) {
+					fullKeyString = fullKeyString.replace(
+						mainSource.name + '.',
+						''
+					);
+				}
+
+				return {
+					by: fullKeyString,
+					type: type
+				};
+			}
+		)
+	);
+}
+
+export async function hasJoinsInSelectStatement(
+	selectStatement: SelectStmt,
+	helpers: {
+		onNestedSelect?: (
+			selectStatement: SelectStmt
+		) => ISelectQueryResult | Promise<ISelectQueryResult>;
+		onDescribeTable?: (tableName: string) => Promise<Table>;
+	} = {
+		onNestedSelect: () => ({
+			columns: [],
+			rows: [],
+			tableName: null,
+			entity: null,
+			total: 0
+		}),
+		onDescribeTable: () => null
+	}
+): Promise<boolean> {
+	const result = await getJoinClausesFromSelectStatement(
+		selectStatement,
+		helpers
+	);
+
+	return !!result.joins.length;
+}
+
+export function getAllSelectedColumnNamesFromSelectClause(
+	selectClause: SelectClause
+): string[] {
+	return selectClause.columns.items.reduce((acc, column) => {
+		if (column.type === 'alias') {
+			const alias = column.alias.text;
+
+			acc.push(alias);
+		} else if (column.type === 'member_expr') {
+			if (column.property.type === 'identifier') {
+				acc.push(column.property.text);
+			}
+		} else if (column.type === 'identifier') {
+			acc.push(column.text);
+		}
+
+		return acc;
+	}, [] as string[]);
+}
+
+// Turns the nested AST structure into a simplified list of flat join query descriptions in the jsstore format
+// Uses the parent statement to find any alias mappings so they can be added to the join query 'as' property
+// If any join clause is a subquery, it will have to be executed separatly by jsstore
+// and passed to the join query as in the 'store' property with the resulting list of rows from that subquery
+export async function flattenJoinExpr(
+	joinExpr: JoinExpr,
+	parentQuery: SelectStmt,
+	helpers: {
+		onNestedSelect?: (
+			selectStatement: SelectStmt
+		) => ISelectQueryResult | Promise<ISelectQueryResult>;
+		onDescribeTable?: (tableName: string) => Promise<Table>;
+	} = {
+		onNestedSelect: () => ({
+			columns: [],
+			rows: [],
+			tableName: null,
+			entity: null,
+			total: 0
+		}),
+		onDescribeTable: () => null
+	}
+): Promise<{
+	joins: IJoinQuery[];
+	columnMappings: searchStatementUtils.IColumnMapping[];
+}> {
+	// const mainSource = getMainSourceFromSelectStatement(parentQuery);
+	let joinExprs: IJoinQuery[] = [];
+	let resultingColumnMappings: searchStatementUtils.IColumnMapping[] = [];
+
+	const joinTable = searchStatementUtils.getJoinTableFromJoinClause(joinExpr);
+
+	if (!joinTable) {
+		return {
+			joins: joinExprs,
+			columnMappings: resultingColumnMappings
+		};
+	}
+
+	const joinType = searchStatementUtils.getJoinTypeFromJoinClause(joinExpr);
+
+	const joinOn = getJoinOnSpecificationAsTextFromJoinExpr(joinExpr);
+
+	const selectClause =
+		searchStatementUtils.getSelectClauseFromSelectStatement(parentQuery);
+
+	const ownMappings =
+		searchStatementUtils.fromSelectClauseColumnsToColumnMappings(
+			selectClause,
+			joinTable
+		);
+
+	if (joinExpr.left.type === 'join_expr') {
+		const newJoinsResult = await flattenJoinExpr(
+			joinExpr.left as JoinExpr,
+			parentQuery,
+			helpers
+		);
+
+		joinExprs.push(...newJoinsResult.joins);
+		resultingColumnMappings.push(...newJoinsResult.columnMappings);
+	}
+
+	if (joinExpr.right.type === 'alias') {
+		if (
+			joinExpr.right.expr.type === 'paren_expr' &&
+			joinExpr.right.expr.expr.type === 'select_stmt'
+		) {
+			const result = await helpers.onNestedSelect?.(
+				joinExpr.right.expr.expr
+			);
+			const nestedAlias = joinExpr.right.alias.text;
+
+			if (!!(result.rows || []).length && !!nestedAlias) {
+				const nestedMappings =
+					searchStatementUtils.fromSelectClauseColumnsToColumnMappings(
+						selectClause,
+						nestedAlias
+					);
+
+				const nested: IJoinQuery = {
+					type: joinType,
+					store: result.rows,
+					meta: {
+						primaryKey: result.columns.find(
+							(col) => col.column.primaryKey
+						)?.column.columnName
+					},
+					with: null,
+					on: joinOn
+				};
+
+				const ownAsObject = fromColumnMappingsToJsStore(nestedMappings);
+
+				if (!isEmpty(ownAsObject)) {
+					nested.as = ownAsObject;
+				}
+
+				// const newMappedColumns: searchStatementUtils.IColumnMapping[] = result.columns.map((col) => {
+				// 	const mapping = nestedMappings.find(
+				// 		(mapping) => mapping.from === col.columnName
+				// 	);
+
+				// 	if (mapping) {
+				// 		return {
+				// 			as: mapping.to,
+				// 			column: col,
+				// 		};
+				// 	}
+
+				// 	return {
+				// 		as: col.as,
+				// 		column: col,
+				// 	}
+				// });
+
+				joinExprs.push(nested);
+				resultingColumnMappings.push(...result.columns);
+			}
+		} else if (joinExpr.right.expr.type === 'identifier') {
+			const nestedAsJoin: IJoinQuery = {
+				type: joinType,
+				with: joinTable,
+				on: joinOn
+			};
+
+			const nestedAsObject = fromColumnMappingsToJsStore(ownMappings);
+
+			if (!isEmpty(nestedAsObject)) {
+				nestedAsJoin.as = nestedAsObject;
+			}
+
+			// TODO: Get all columns of this table, then map the ones that changed to the new names
+			const table = await helpers.onDescribeTable?.(joinTable);
+
+			if (table) {
+				const newMappedColumns: searchStatementUtils.IColumnMapping[] =
+					table.columns.map((col) => {
+						const mapping = ownMappings.find(
+							(mapping) => mapping.from === col.columnName
+						);
+
+						if (mapping) {
+							return {
+								as: mapping.to,
+								column: col
+							};
+						}
+
+						return {
+							as: col.columnName,
+							column: col
+						};
+					});
+
+				resultingColumnMappings.push(...newMappedColumns);
+			}
+
+			joinExprs.push(nestedAsJoin);
+		}
+	} else if (joinExpr.right.type === 'identifier') {
+		const nestedAsJoin: IJoinQuery = {
+			type: joinType,
+			with: joinTable,
+			on: joinOn
+		};
+
+		const nestedAsObject = fromColumnMappingsToJsStore(ownMappings);
+
+		if (!isEmpty(nestedAsObject)) {
+			nestedAsJoin.as = nestedAsObject;
+		}
+
+		// TODO: Get all columns of this table, then map the ones that changed to the new names
+		const table = await helpers.onDescribeTable?.(joinTable);
+
+		if (table) {
+			const newMappedColumns: searchStatementUtils.IColumnMapping[] =
+				table.columns.map((col) => {
+					const mapping = ownMappings.find(
+						(mapping) => mapping.from === col.columnName
+					);
+					// const columnUITransfer = fromColumnInstanceToColumnTransfer(
+					// 	col
+					// );
+
+					if (mapping) {
+						return {
+							as: mapping.to,
+							column: col
+						};
+					}
+
+					return {
+						as: col.columnName,
+						column: col
+					};
+				});
+
+			resultingColumnMappings.push(...newMappedColumns);
+		}
+
+		joinExprs.push(nestedAsJoin);
+	}
+
+	return {
+		joins: joinExprs,
+		columnMappings: resultingColumnMappings
+	};
+}
+
+export function flattenJoinExprSync(
+	joinExpr: JoinExpr,
+	parentQuery: SelectStmt,
+	helpers: {
+		onDescribeTable?: (tableName: string) => Table;
+	} = {
+		onDescribeTable: () => null
+	}
+): {
+	joins: IJoinQuery[];
+	columnMappings: searchStatementUtils.IColumnMapping[];
+} {
+	let joinExprs: IJoinQuery[] = [];
+	let resultingColumnMappings: searchStatementUtils.IColumnMapping[] = [];
+
+	const joinTable = searchStatementUtils.getJoinTableFromJoinClause(joinExpr);
+
+	if (!joinTable) {
+		return {
+			joins: joinExprs,
+			columnMappings: resultingColumnMappings
+		};
+	}
+
+	const joinType = searchStatementUtils.getJoinTypeFromJoinClause(joinExpr);
+
+	const joinOn = getJoinOnSpecificationAsTextFromJoinExpr(joinExpr);
+
+	const selectClause =
+		searchStatementUtils.getSelectClauseFromSelectStatement(parentQuery);
+
+	const ownMappings =
+		searchStatementUtils.fromSelectClauseColumnsToColumnMappings(
+			selectClause,
+			joinTable
+		);
+
+	if (joinExpr.left.type === 'join_expr') {
+		const newJoinsResult = flattenJoinExprSync(
+			joinExpr.left as JoinExpr,
+			parentQuery,
+			helpers
+		);
+
+		joinExprs.push(...newJoinsResult.joins);
+		resultingColumnMappings.push(...newJoinsResult.columnMappings);
+	}
+
+	if (joinExpr.right.type === 'alias') {
+		if (
+			joinExpr.right.expr.type === 'paren_expr' &&
+			joinExpr.right.expr.expr.type === 'select_stmt'
+		) {
+			const mainSubSelect = joinExpr.right.expr.expr as SelectStmt;
+			const mainSubQuery =
+				searchStatementUtils.getMainSourceFromSelectStatement(
+					mainSubSelect
+				);
+
+			const result: ISelectQueryResult = {
+				columns: [],
+				rows: [],
+				tableName: null,
+				entity: null,
+				total: 0
+			};
+
+			if (mainSubQuery?.type === 'table') {
+				const table = helpers.onDescribeTable?.(mainSubQuery.name);
+				const selectClause =
+					searchStatementUtils.getSelectClauseFromSelectStatement(
+						mainSubSelect
+					);
+				const subQueryMappings =
+					searchStatementUtils.fromSelectClauseColumnsToColumnMappings(
+						selectClause,
+						mainSubQuery.name
+					);
+
+				if (table) {
+					result.columns = table.columns.map((col) => {
+						const mapping = subQueryMappings.find(
+							(mapping) => mapping.from === col.columnName
+						);
+
+						if (mapping) {
+							return {
+								as: mapping.to,
+								column: col
+							};
+						}
+
+						return {
+							as: col.columnName,
+							column: col
+						};
+					});
+				}
+
+				resultingColumnMappings.push(...result.columns);
+			}
+
+			const nestedAlias = joinExpr.right.alias.text;
+
+			if (!!(result.rows || []).length && !!nestedAlias) {
+				const nestedMappings =
+					searchStatementUtils.fromSelectClauseColumnsToColumnMappings(
+						selectClause,
+						nestedAlias
+					);
+
+				const nested: IJoinQuery = {
+					type: joinType,
+					store: result.rows,
+					meta: {
+						primaryKey: result.columns.find(
+							(col) => col.column.primaryKey
+						)?.column.columnName
+					},
+					with: null,
+					on: joinOn
+				};
+
+				const ownAsObject = fromColumnMappingsToJsStore(nestedMappings);
+
+				if (!isEmpty(ownAsObject)) {
+					nested.as = ownAsObject;
+				}
+
+				joinExprs.push(nested);
+			}
+		} else if (joinExpr.right.expr.type === 'identifier') {
+			const nestedAsJoin: IJoinQuery = {
+				type: joinType,
+				with: joinTable,
+				on: joinOn
+			};
+
+			const nestedAsObject = fromColumnMappingsToJsStore(ownMappings);
+
+			if (!isEmpty(nestedAsObject)) {
+				nestedAsJoin.as = nestedAsObject;
+			}
+
+			const table = helpers.onDescribeTable?.(joinTable);
+
+			if (table) {
+				const newMappedColumns: searchStatementUtils.IColumnMapping[] =
+					table.columns.map((col) => {
+						const mapping = ownMappings.find(
+							(mapping) => mapping.from === col.columnName
+						);
+
+						if (mapping) {
+							return {
+								as: mapping.to,
+								column: col
+							};
+						}
+
+						return {
+							as: col.columnName,
+							column: col
+						};
+					});
+
+				resultingColumnMappings.push(...newMappedColumns);
+			}
+
+			joinExprs.push(nestedAsJoin);
+		}
+	} else if (joinExpr.right.type === 'identifier') {
+		const nestedAsJoin: IJoinQuery = {
+			type: joinType,
+			with: joinTable,
+			on: joinOn
+		};
+
+		const nestedAsObject = fromColumnMappingsToJsStore(ownMappings);
+
+		if (!isEmpty(nestedAsObject)) {
+			nestedAsJoin.as = nestedAsObject;
+		}
+
+		const table = helpers.onDescribeTable?.(joinTable);
+
+		if (table) {
+			const newMappedColumns: searchStatementUtils.IColumnMapping[] =
+				table.columns.map((col) => {
+					const mapping = ownMappings.find(
+						(mapping) => mapping.from === col.columnName
+					);
+
+					if (mapping) {
+						return {
+							as: mapping.to,
+							column: col
+						};
+					}
+
+					return {
+						as: col.columnName,
+						column: col
+					};
+				});
+
+			resultingColumnMappings.push(...newMappedColumns);
+		}
+
+		joinExprs.push(nestedAsJoin);
+	}
+
+	return {
+		joins: joinExprs,
+		columnMappings: resultingColumnMappings
+	};
+}
+
+export function getJoinClausesFromSelectStatementSync(
+	selectStatement: SelectStmt,
+	helpers: {
+		onDescribeTable?: (tableName: string) => Table;
+	} = {
+		onDescribeTable: () => null
+	}
+): {
+	joins: IJoinQuery[];
+	// Returns any selected columns in the joins with their alias names
+	// So we can map them to the correct column names in the resulting rows
+	columnMappings: searchStatementUtils.IColumnMapping[];
+} {
+	const fromClause =
+		searchStatementUtils.getFromClauseFromSelectStatement(selectStatement);
+
+	if (!fromClause) {
+		return {
+			joins: [],
+			columnMappings: []
+		};
+	}
+
+	if (fromClause.expr.type === 'join_expr') {
+		return flattenJoinExprSync(
+			fromClause.expr as JoinExpr,
+			selectStatement,
+			helpers
+		);
+	}
+
+	return {
+		joins: [],
+		columnMappings: []
+	};
+}
+
+export async function getJoinClausesFromSelectStatement(
+	selectStatement: SelectStmt,
+	helpers: {
+		onNestedSelect?: (
+			selectStatement: SelectStmt
+		) => ISelectQueryResult | Promise<ISelectQueryResult>;
+		onDescribeTable?: (tableName: string) => Promise<Table>;
+	} = {
+		onNestedSelect: () => ({
+			columns: [],
+			rows: [],
+			tableName: null,
+			entity: null,
+			total: 0
+		}),
+		onDescribeTable: () => null
+	}
+): Promise<{
+	joins: IJoinQuery[];
+	// Returns any selected columns in the joins with their alias names
+	// So we can map them to the correct column names in the resulting rows
+	columnMappings: searchStatementUtils.IColumnMapping[];
+}> {
+	const fromClause =
+		searchStatementUtils.getFromClauseFromSelectStatement(selectStatement);
+
+	if (!fromClause) {
+		return {
+			joins: [],
+			columnMappings: []
+		};
+	}
+
+	if (fromClause.expr.type === 'join_expr') {
+		return flattenJoinExpr(
+			fromClause.expr as JoinExpr,
+			selectStatement,
+			helpers
+		);
+	}
+
+	return {
+		joins: [],
+		columnMappings: []
+	};
+}
+
+export function getJoinOnSpecificationAsTextFromJoinExpr(
+	joinClause: JoinExpr
+): string {
+	let text = '';
+
+	if (joinClause.specification?.expr.type === 'binary_expr') {
+		if (joinClause.specification.expr.left.type === 'member_expr') {
+			if (
+				joinClause.specification.expr.left.object.type === 'identifier'
+			) {
+				text += joinClause.specification.expr.left.object.text;
+			}
+
+			if (
+				joinClause.specification.expr.left.property.type ===
+				'identifier'
+			) {
+				text += '.' + joinClause.specification.expr.left.property.text;
+			}
+		} else if (joinClause.specification.expr.left.type === 'identifier') {
+			text += joinClause.specification.expr.left.text;
+		} else if (
+			joinClause.specification.expr.left.type === 'number_literal'
+		) {
+			text += joinClause.specification.expr.left.value;
+		} else if (
+			joinClause.specification.expr.left.type === 'string_literal'
+		) {
+			text += `'` + joinClause.specification.expr.left.value + `'`;
+		} else if (
+			joinClause.specification.expr.left.type === 'boolean_literal'
+		) {
+			text += joinClause.specification.expr.left.value;
+		} else if (joinClause.specification.expr.left.type === 'null_literal') {
+			text += joinClause.specification.expr.left.value;
+		}
+
+		text += joinClause.specification.expr.operator;
+
+		if (joinClause.specification.expr.right.type === 'member_expr') {
+			if (
+				joinClause.specification.expr.right.object.type === 'identifier'
+			) {
+				text += joinClause.specification.expr.right.object.text;
+			}
+
+			if (
+				joinClause.specification.expr.right.property.type ===
+				'identifier'
+			) {
+				text += '.' + joinClause.specification.expr.right.property.text;
+			}
+		} else if (joinClause.specification.expr.right.type === 'identifier') {
+			text += joinClause.specification.expr.right.text;
+		} else if (
+			joinClause.specification.expr.right.type === 'number_literal'
+		) {
+			text += joinClause.specification.expr.right.value;
+		} else if (
+			joinClause.specification.expr.right.type === 'string_literal'
+		) {
+			text += `'` + joinClause.specification.expr.right.value + `'`;
+		} else if (
+			joinClause.specification.expr.right.type === 'boolean_literal'
+		) {
+			text += joinClause.specification.expr.right.value;
+		} else if (
+			joinClause.specification.expr.right.type === 'null_literal'
+		) {
+			text += joinClause.specification.expr.right.value;
+		}
+	}
+
+	return text;
+}
+
+export function resolveDatabase(
+	project: EditorService,
+	entity?: DefinitionEntityState
+): Database {
+	if (!!entity) {
+		return project.localDatabaseStore?.getDatabaseForPersistedEntity(
+			entity
+		);
+	}
+
+	const databaseEntities = getDatabaseEntities(project.logic);
+
+	const defaultDatabase = databaseEntities.find((dbEntity) => {
+		const defaultProperty = dbEntity.properties.find((propt) => {
+			return propt.implements.find(
+				(impl) =>
+					impl.id ===
+					BUILT_IN_BASE_ENTITY_IDS['built-in-base-entity']
+						.BUILT_IN_RELATIONAL_DATABASE_ENTITY.properties.default
+						.id
+			);
+		});
+
+		const value = defaultProperty?.getDefaultValue()?.value;
+
+		return value === true;
+	});
+
+	if (!!defaultDatabase) {
+		return project.localDatabaseStore?.getDatabase(defaultDatabase.id);
+	}
+
+	if (!!databaseEntities.length) {
+		return project.localDatabaseStore?.getDatabase(databaseEntities[0].id);
+	}
+
+	return null;
+}