azure-mock 2.20.0 → 2.22.0

package/dist/session-CAUQtT0A-BoVK2x7A.js

@@ -0,0 +1,745 @@
+import { C as sql, b as is, d as Table, g as entityKind, h as WithSubquery, n as Columns, r as Param, s as SQL } from "./sql-CNZp2yLp-Bwugq384.js";
+import { D as haveSameKeys, E as hashQuery, N as mapUpdateSet, f as SelectionProxyHandler, i as DrizzleQueryError, j as mapRelationalRow, o as NoopCache, p as TransactionRollbackError, u as QueryPromise } from "./logger-TIsK7375-CLNNa25D.js";
+import { n as MySqlSelectBuilder, o as QueryBuilder, s as extractUsedTable } from "./query-builder-CLJAKedv-DTZiP7B6.js";
+//#region ../db/dist/session-CAUQtT0A.js
+var MySqlCountBuilder = class MySqlCountBuilder extends SQL {
+	constructor(params) {
+		super(MySqlCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
+		this.params = params;
+		this.mapWith(Number);
+		this.session = params.session;
+		this.sql = MySqlCountBuilder.buildCount(params.source, params.filters);
+	}
+	sql;
+	static [entityKind] = "MySqlCountBuilder";
+	[Symbol.toStringTag] = "MySqlCountBuilder";
+	session;
+	static buildEmbeddedCount(source, filters) {
+		return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
+	}
+	static buildCount(source, filters) {
+		return sql`select count(*) as count from ${source}${sql.raw(" where ").if(filters)}${filters}`;
+	}
+	then(onfulfilled, onrejected) {
+		return Promise.resolve(this.session.count(this.sql)).then(onfulfilled, onrejected);
+	}
+	catch(onRejected) {
+		return this.then(void 0, onRejected);
+	}
+	finally(onFinally) {
+		return this.then((value) => {
+			onFinally?.();
+			return value;
+		}, (reason) => {
+			onFinally?.();
+			throw reason;
+		});
+	}
+};
+var MySqlDeleteBase = class extends QueryPromise {
+	constructor(table, session, dialect, withList) {
+		super();
+		this.table = table;
+		this.session = session;
+		this.dialect = dialect;
+		this.config = {
+			table,
+			withList
+		};
+	}
+	static [entityKind] = "MySqlDelete";
+	config;
+	/**
+	* Adds a `where` clause to the query.
+	*
+	* Calling this method will delete only those rows that fulfill a specified condition.
+	*
+	* See docs: {@link https://orm.drizzle.team/docs/delete}
+	*
+	* @param where the `where` clause.
+	*
+	* @example
+	* You can use conditional operators and `sql function` to filter the rows to be deleted.
+	*
+	* ```ts
+	* // Delete all cars with green color
+	* db.delete(cars).where(eq(cars.color, 'green'));
+	* // or
+	* db.delete(cars).where(sql`${cars.color} = 'green'`)
+	* ```
+	*
+	* You can logically combine conditional operators with `and()` and `or()` operators:
+	*
+	* ```ts
+	* // Delete all BMW cars with a green color
+	* db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+	*
+	* // Delete all cars with the green or blue color
+	* db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+	* ```
+	*/
+	where(where) {
+		this.config.where = where;
+		return this;
+	}
+	orderBy(...columns) {
+		if (typeof columns[0] === "function") {
+			const orderBy = columns[0](new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
+				sqlAliasedBehavior: "alias",
+				sqlBehavior: "sql"
+			})));
+			const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+			this.config.orderBy = orderByArray;
+		} else {
+			const orderByArray = columns;
+			this.config.orderBy = orderByArray;
+		}
+		return this;
+	}
+	limit(limit) {
+		this.config.limit = limit;
+		return this;
+	}
+	/** @internal */
+	getSQL() {
+		return this.dialect.buildDeleteQuery(this.config);
+	}
+	toSQL() {
+		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+		return rest;
+	}
+	prepare() {
+		return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, void 0, void 0, void 0, {
+			type: "delete",
+			tables: extractUsedTable(this.config.table)
+		});
+	}
+	execute = (placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	};
+	createIterator = () => {
+		const self = this;
+		return async function* (placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+	iterator = this.createIterator();
+	$dynamic() {
+		return this;
+	}
+};
+var MySqlInsertBuilder = class {
+	constructor(table, session, dialect) {
+		this.table = table;
+		this.session = session;
+		this.dialect = dialect;
+	}
+	static [entityKind] = "MySqlInsertBuilder";
+	shouldIgnore = false;
+	ignore() {
+		this.shouldIgnore = true;
+		return this;
+	}
+	values(values) {
+		values = Array.isArray(values) ? values : [values];
+		if (values.length === 0) throw new Error("values() must be called with at least one value");
+		const mappedValues = values.map((entry) => {
+			const result = {};
+			const cols = this.table[Table.Symbol.Columns];
+			for (const colKey of Object.keys(entry)) {
+				const colValue = entry[colKey];
+				result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
+			}
+			return result;
+		});
+		return new MySqlInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
+	}
+	select(selectQuery) {
+		const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder()) : selectQuery;
+		if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) throw new Error("Insert select error: selected fields are not the same or are in a different order compared to the table definition");
+		return new MySqlInsertBase(this.table, select, this.shouldIgnore, this.session, this.dialect, true);
+	}
+};
+var MySqlInsertBase = class extends QueryPromise {
+	constructor(table, values, ignore, session, dialect, select) {
+		super();
+		this.session = session;
+		this.dialect = dialect;
+		this.config = {
+			table,
+			values,
+			select,
+			ignore
+		};
+	}
+	static [entityKind] = "MySqlInsert";
+	config;
+	cacheConfig;
+	/**
+	* Adds an `on duplicate key update` clause to the query.
+	*
+	* Calling this method will update the row if any unique index conflicts. MySQL will automatically determine the conflict target based on the primary key and unique indexes.
+	*
+	* See docs: {@link https://orm.drizzle.team/docs/insert#on-duplicate-key-update}
+	*
+	* @param config The `set` clause
+	*
+	* @example
+	* ```ts
+	* await db.insert(cars)
+	*   .values({ id: 1, brand: 'BMW'})
+	*   .onDuplicateKeyUpdate({ set: { brand: 'Porsche' }});
+	* ```
+	*
+	* While MySQL does not directly support doing nothing on conflict, you can perform a no-op by setting any column's value to itself and achieve the same effect:
+	*
+	* ```ts
+	* import { sql } from 'drizzle-orm';
+	*
+	* await db.insert(cars)
+	*   .values({ id: 1, brand: 'BMW' })
+	*   .onDuplicateKeyUpdate({ set: { id: sql`id` } });
+	* ```
+	*/
+	onDuplicateKeyUpdate(config) {
+		const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
+		this.config.onConflict = sql`update ${setSql}`;
+		return this;
+	}
+	$returningId() {
+		const returning = [];
+		for (const [key, value] of Object.entries(this.config.table[Table.Symbol.Columns])) if (value.primary) returning.push({
+			field: value,
+			path: [key]
+		});
+		this.config.returning = returning;
+		return this;
+	}
+	/** @internal */
+	getSQL() {
+		return this.dialect.buildInsertQuery(this.config).sql;
+	}
+	toSQL() {
+		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+		return rest;
+	}
+	prepare() {
+		const { sql: sql2, generatedIds } = this.dialect.buildInsertQuery(this.config);
+		return this.session.prepareQuery(this.dialect.sqlToQuery(sql2), void 0, void 0, generatedIds, this.config.returning, {
+			type: "insert",
+			tables: extractUsedTable(this.config.table)
+		}, this.cacheConfig);
+	}
+	execute = (placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	};
+	createIterator = () => {
+		const self = this;
+		return async function* (placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+	iterator = this.createIterator();
+	$dynamic() {
+		return this;
+	}
+};
+var MySqlUpdateBuilder = class {
+	constructor(table, session, dialect, withList) {
+		this.table = table;
+		this.session = session;
+		this.dialect = dialect;
+		this.withList = withList;
+	}
+	static [entityKind] = "MySqlUpdateBuilder";
+	set(values) {
+		return new MySqlUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect, this.withList);
+	}
+};
+var MySqlUpdateBase = class extends QueryPromise {
+	constructor(table, set, session, dialect, withList) {
+		super();
+		this.session = session;
+		this.dialect = dialect;
+		this.config = {
+			set,
+			table,
+			withList
+		};
+	}
+	static [entityKind] = "MySqlUpdate";
+	config;
+	cacheConfig;
+	/**
+	* Adds a 'where' clause to the query.
+	*
+	* Calling this method will update only those rows that fulfill a specified condition.
+	*
+	* See docs: {@link https://orm.drizzle.team/docs/update}
+	*
+	* @param where the 'where' clause.
+	*
+	* @example
+	* You can use conditional operators and `sql function` to filter the rows to be updated.
+	*
+	* ```ts
+	* // Update all cars with green color
+	* db.update(cars).set({ color: 'red' })
+	*   .where(eq(cars.color, 'green'));
+	* // or
+	* db.update(cars).set({ color: 'red' })
+	*   .where(sql`${cars.color} = 'green'`)
+	* ```
+	*
+	* You can logically combine conditional operators with `and()` and `or()` operators:
+	*
+	* ```ts
+	* // Update all BMW cars with a green color
+	* db.update(cars).set({ color: 'red' })
+	*   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+	*
+	* // Update all cars with the green or blue color
+	* db.update(cars).set({ color: 'red' })
+	*   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+	* ```
+	*/
+	where(where) {
+		this.config.where = where;
+		return this;
+	}
+	orderBy(...columns) {
+		if (typeof columns[0] === "function") {
+			const orderBy = columns[0](new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
+				sqlAliasedBehavior: "alias",
+				sqlBehavior: "sql"
+			})));
+			const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+			this.config.orderBy = orderByArray;
+		} else {
+			const orderByArray = columns;
+			this.config.orderBy = orderByArray;
+		}
+		return this;
+	}
+	limit(limit) {
+		this.config.limit = limit;
+		return this;
+	}
+	/** @internal */
+	getSQL() {
+		return this.dialect.buildUpdateQuery(this.config);
+	}
+	toSQL() {
+		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+		return rest;
+	}
+	prepare() {
+		return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), void 0, void 0, void 0, this.config.returning, {
+			type: "insert",
+			tables: extractUsedTable(this.config.table)
+		}, this.cacheConfig);
+	}
+	execute = (placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	};
+	createIterator = () => {
+		const self = this;
+		return async function* (placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+	iterator = this.createIterator();
+	$dynamic() {
+		return this;
+	}
+};
+var RelationalQueryBuilder = class {
+	constructor(fullSchema, schema, tableNamesMap, table, tableConfig, dialect, session, mode) {
+		this.fullSchema = fullSchema;
+		this.schema = schema;
+		this.tableNamesMap = tableNamesMap;
+		this.table = table;
+		this.tableConfig = tableConfig;
+		this.dialect = dialect;
+		this.session = session;
+		this.mode = mode;
+	}
+	static [entityKind] = "MySqlRelationalQueryBuilder";
+	findMany(config) {
+		return new MySqlRelationalQuery(this.fullSchema, this.schema, this.tableNamesMap, this.table, this.tableConfig, this.dialect, this.session, config ? config : {}, "many", this.mode);
+	}
+	findFirst(config) {
+		return new MySqlRelationalQuery(this.fullSchema, this.schema, this.tableNamesMap, this.table, this.tableConfig, this.dialect, this.session, config ? {
+			...config,
+			limit: 1
+		} : { limit: 1 }, "first", this.mode);
+	}
+};
+var MySqlRelationalQuery = class extends QueryPromise {
+	constructor(fullSchema, schema, tableNamesMap, table, tableConfig, dialect, session, config, queryMode, mode) {
+		super();
+		this.fullSchema = fullSchema;
+		this.schema = schema;
+		this.tableNamesMap = tableNamesMap;
+		this.table = table;
+		this.tableConfig = tableConfig;
+		this.dialect = dialect;
+		this.session = session;
+		this.config = config;
+		this.queryMode = queryMode;
+		this.mode = mode;
+	}
+	static [entityKind] = "MySqlRelationalQuery";
+	prepare() {
+		const { query, builtQuery } = this._toSQL();
+		return this.session.prepareQuery(builtQuery, void 0, (rawRows) => {
+			const rows = rawRows.map((row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection));
+			if (this.queryMode === "first") return rows[0];
+			return rows;
+		});
+	}
+	_getQuery() {
+		return this.mode === "planetscale" ? this.dialect.buildRelationalQueryWithoutLateralSubqueries({
+			fullSchema: this.fullSchema,
+			schema: this.schema,
+			tableNamesMap: this.tableNamesMap,
+			table: this.table,
+			tableConfig: this.tableConfig,
+			queryConfig: this.config,
+			tableAlias: this.tableConfig.tsName
+		}) : this.dialect.buildRelationalQuery({
+			fullSchema: this.fullSchema,
+			schema: this.schema,
+			tableNamesMap: this.tableNamesMap,
+			table: this.table,
+			tableConfig: this.tableConfig,
+			queryConfig: this.config,
+			tableAlias: this.tableConfig.tsName
+		});
+	}
+	_toSQL() {
+		const query = this._getQuery();
+		return {
+			builtQuery: this.dialect.sqlToQuery(query.sql),
+			query
+		};
+	}
+	/** @internal */
+	getSQL() {
+		return this._getQuery().sql;
+	}
+	toSQL() {
+		return this._toSQL().builtQuery;
+	}
+	execute() {
+		return this.prepare().execute();
+	}
+};
+var MySqlDatabase = class {
+	constructor(dialect, session, schema, mode) {
+		this.dialect = dialect;
+		this.session = session;
+		this.mode = mode;
+		this._ = schema ? {
+			schema: schema.schema,
+			fullSchema: schema.fullSchema,
+			tableNamesMap: schema.tableNamesMap
+		} : {
+			schema: void 0,
+			fullSchema: {},
+			tableNamesMap: {}
+		};
+		this.query = {};
+		if (this._.schema) for (const [tableName, columns] of Object.entries(this._.schema)) this.query[tableName] = new RelationalQueryBuilder(schema.fullSchema, this._.schema, this._.tableNamesMap, schema.fullSchema[tableName], columns, dialect, session, this.mode);
+		this.$cache = { invalidate: async (_params) => {} };
+	}
+	static [entityKind] = "MySqlDatabase";
+	query;
+	/**
+	* Creates a subquery that defines a temporary named result set as a CTE.
+	*
+	* It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+	*
+	* See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	*
+	* @param alias The alias for the subquery.
+	*
+	* Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+	*
+	* @example
+	*
+	* ```ts
+	* // Create a subquery with alias 'sq' and use it in the select query
+	* const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	*
+	* const result = await db.with(sq).select().from(sq);
+	* ```
+	*
+	* To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+	*
+	* ```ts
+	* // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+	* const sq = db.$with('sq').as(db.select({
+	*   name: sql<string>`upper(${users.name})`.as('name'),
+	* })
+	* .from(users));
+	*
+	* const result = await db.with(sq).select({ name: sq.name }).from(sq);
+	* ```
+	*/
+	$with = (alias, selection) => {
+		const self = this;
+		const as = (qb) => {
+			if (typeof qb === "function") qb = qb(new QueryBuilder(self.dialect));
+			return new Proxy(new WithSubquery(qb.getSQL(), selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}), alias, true), new SelectionProxyHandler({
+				alias,
+				sqlAliasedBehavior: "alias",
+				sqlBehavior: "error"
+			}));
+		};
+		return { as };
+	};
+	$count(source, filters) {
+		return new MySqlCountBuilder({
+			source,
+			filters,
+			session: this.session
+		});
+	}
+	$cache;
+	/**
+	* Incorporates a previously defined CTE (using `$with`) into the main query.
+	*
+	* This method allows the main query to reference a temporary named result set.
+	*
+	* See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+	*
+	* @param queries The CTEs to incorporate into the main query.
+	*
+	* @example
+	*
+	* ```ts
+	* // Define a subquery 'sq' as a CTE using $with
+	* const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+	*
+	* // Incorporate the CTE 'sq' into the main query and select from it
+	* const result = await db.with(sq).select().from(sq);
+	* ```
+	*/
+	with(...queries) {
+		const self = this;
+		function select(fields) {
+			return new MySqlSelectBuilder({
+				fields: fields ?? void 0,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries
+			});
+		}
+		function selectDistinct(fields) {
+			return new MySqlSelectBuilder({
+				fields: fields ?? void 0,
+				session: self.session,
+				dialect: self.dialect,
+				withList: queries,
+				distinct: true
+			});
+		}
+		function update(table) {
+			return new MySqlUpdateBuilder(table, self.session, self.dialect, queries);
+		}
+		function delete_(table) {
+			return new MySqlDeleteBase(table, self.session, self.dialect, queries);
+		}
+		return {
+			select,
+			selectDistinct,
+			update,
+			delete: delete_
+		};
+	}
+	select(fields) {
+		return new MySqlSelectBuilder({
+			fields: fields ?? void 0,
+			session: this.session,
+			dialect: this.dialect
+		});
+	}
+	selectDistinct(fields) {
+		return new MySqlSelectBuilder({
+			fields: fields ?? void 0,
+			session: this.session,
+			dialect: this.dialect,
+			distinct: true
+		});
+	}
+	/**
+	* Creates an update query.
+	*
+	* Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+	*
+	* Use `.set()` method to specify which values to update.
+	*
+	* See docs: {@link https://orm.drizzle.team/docs/update}
+	*
+	* @param table The table to update.
+	*
+	* @example
+	*
+	* ```ts
+	* // Update all rows in the 'cars' table
+	* await db.update(cars).set({ color: 'red' });
+	*
+	* // Update rows with filters and conditions
+	* await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+	* ```
+	*/
+	update(table) {
+		return new MySqlUpdateBuilder(table, this.session, this.dialect);
+	}
+	/**
+	* Creates an insert query.
+	*
+	* Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+	*
+	* See docs: {@link https://orm.drizzle.team/docs/insert}
+	*
+	* @param table The table to insert into.
+	*
+	* @example
+	*
+	* ```ts
+	* // Insert one row
+	* await db.insert(cars).values({ brand: 'BMW' });
+	*
+	* // Insert multiple rows
+	* await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+	* ```
+	*/
+	insert(table) {
+		return new MySqlInsertBuilder(table, this.session, this.dialect);
+	}
+	/**
+	* Creates a delete query.
+	*
+	* Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+	*
+	* See docs: {@link https://orm.drizzle.team/docs/delete}
+	*
+	* @param table The table to delete from.
+	*
+	* @example
+	*
+	* ```ts
+	* // Delete all rows in the 'cars' table
+	* await db.delete(cars);
+	*
+	* // Delete rows with filters and conditions
+	* await db.delete(cars).where(eq(cars.color, 'green'));
+	* ```
+	*/
+	delete(table) {
+		return new MySqlDeleteBase(table, this.session, this.dialect);
+	}
+	execute(query) {
+		return this.session.execute(typeof query === "string" ? sql.raw(query) : query.getSQL());
+	}
+	transaction(transaction, config) {
+		return this.session.transaction(transaction, config);
+	}
+};
+var MySqlPreparedQuery = class {
+	constructor(cache, queryMetadata, cacheConfig) {
+		this.cache = cache;
+		this.queryMetadata = queryMetadata;
+		this.cacheConfig = cacheConfig;
+		if (cache && cache.strategy() === "all" && cacheConfig === void 0) this.cacheConfig = {
+			enable: true,
+			autoInvalidate: true
+		};
+		if (!this.cacheConfig?.enable) this.cacheConfig = void 0;
+	}
+	static [entityKind] = "MySqlPreparedQuery";
+	/** @internal */
+	async queryWithCache(queryString, params, query) {
+		if (this.cache === void 0 || is(this.cache, NoopCache) || this.queryMetadata === void 0) try {
+			return await query();
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e);
+		}
+		if (this.cacheConfig && !this.cacheConfig.enable) try {
+			return await query();
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e);
+		}
+		if ((this.queryMetadata.type === "insert" || this.queryMetadata.type === "update" || this.queryMetadata.type === "delete") && this.queryMetadata.tables.length > 0) try {
+			const [res] = await Promise.all([query(), this.cache.onMutate({ tables: this.queryMetadata.tables })]);
+			return res;
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e);
+		}
+		if (!this.cacheConfig) try {
+			return await query();
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e);
+		}
+		if (this.queryMetadata.type === "select") {
+			const fromCache = await this.cache.get(this.cacheConfig.tag ?? await hashQuery(queryString, params), this.queryMetadata.tables, this.cacheConfig.tag !== void 0, this.cacheConfig.autoInvalidate);
+			if (fromCache === void 0) {
+				let result;
+				try {
+					result = await query();
+				} catch (e) {
+					throw new DrizzleQueryError(queryString, params, e);
+				}
+				await this.cache.put(this.cacheConfig.tag ?? await hashQuery(queryString, params), result, this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [], this.cacheConfig.tag !== void 0, this.cacheConfig.config);
+				return result;
+			}
+			return fromCache;
+		}
+		try {
+			return await query();
+		} catch (e) {
+			throw new DrizzleQueryError(queryString, params, e);
+		}
+	}
+	/** @internal */
+	joinsNotNullableMap;
+};
+var MySqlSession = class {
+	constructor(dialect) {
+		this.dialect = dialect;
+	}
+	static [entityKind] = "MySqlSession";
+	execute(query) {
+		return this.prepareQuery(this.dialect.sqlToQuery(query), void 0).execute();
+	}
+	async count(sql2) {
+		const res = await this.execute(sql2);
+		return Number(res[0][0]["count"]);
+	}
+	getSetTransactionSQL(config) {
+		const parts = [];
+		if (config.isolationLevel) parts.push(`isolation level ${config.isolationLevel}`);
+		return parts.length ? sql`set transaction ${sql.raw(parts.join(" "))}` : void 0;
+	}
+	getStartTransactionSQL(config) {
+		const parts = [];
+		if (config.withConsistentSnapshot) parts.push("with consistent snapshot");
+		if (config.accessMode) parts.push(config.accessMode);
+		return parts.length ? sql`start transaction ${sql.raw(parts.join(" "))}` : void 0;
+	}
+};
+var MySqlTransaction = class extends MySqlDatabase {
+	constructor(dialect, session, schema, nestedIndex, mode) {
+		super(dialect, session, schema, mode);
+		this.schema = schema;
+		this.nestedIndex = nestedIndex;
+	}
+	static [entityKind] = "MySqlTransaction";
+	rollback() {
+		throw new TransactionRollbackError();
+	}
+};
+//#endregion
+export { MySqlTransaction as i, MySqlPreparedQuery as n, MySqlSession as r, MySqlDatabase as t };