@atscript/db-mysql 0.1.38

package/dist/index.mjs

@@ -0,0 +1,1202 @@
+import { AtscriptDbView, BaseDbAdapter, DbError, DbSpace } from "@atscript/db";
+import { buildAggregateCount, buildAggregateSelect, buildCreateView, buildDelete, buildInsert, buildSelect, buildUpdate, buildWhere as buildWhere$1, defaultValueForType, defaultValueToSqlLiteral, refActionToSql, toSqlValue } from "@atscript/db-sql-tools";
+import { AnnotationSpec } from "@atscript/core";
+
+//#region packages/db-mysql/src/sql-builder.ts
+function esc(name) {
+	return name.replace(/`/g, "``");
+}
+function qi(name) {
+	return `\`${esc(name)}\``;
+}
+function quoteTableName(name) {
+	const dot = name.indexOf(".");
+	if (dot >= 0) return `${qi(name.slice(0, dot))}.${qi(name.slice(dot + 1))}`;
+	return qi(name);
+}
+const mysqlDialect = {
+	quoteIdentifier(name) {
+		return qi(name);
+	},
+	quoteTable(name) {
+		return quoteTableName(name);
+	},
+	unlimitedLimit: "18446744073709551615",
+	toValue: toSqlValue,
+	toParam(value) {
+		if (value === undefined) return null;
+		return typeof value === "boolean" ? value ? 1 : 0 : value;
+	},
+	regex(quotedCol, value) {
+		const pattern = value instanceof RegExp ? value.source : String(value);
+		return {
+			sql: `${quotedCol} REGEXP ?`,
+			params: [pattern]
+		};
+	},
+	createViewPrefix: "CREATE OR REPLACE VIEW"
+};
+function buildInsert$1(table, data) {
+	return buildInsert(mysqlDialect, table, data);
+}
+function buildSelect$1(table, where, controls) {
+	return buildSelect(mysqlDialect, table, where, controls);
+}
+function buildUpdate$1(table, data, where, limit) {
+	return buildUpdate(mysqlDialect, table, data, where, limit);
+}
+function buildDelete$1(table, where, limit) {
+	return buildDelete(mysqlDialect, table, where, limit);
+}
+function buildCreateView$1(viewName, plan, columns, resolveFieldRef) {
+	return buildCreateView(mysqlDialect, viewName, plan, columns, resolveFieldRef);
+}
+function buildAggregateSelect$1(table, where, controls) {
+	return buildAggregateSelect(mysqlDialect, table, where, controls);
+}
+function buildAggregateCount$1(table, where, controls) {
+	return buildAggregateCount(mysqlDialect, table, where, controls);
+}
+function collationToMysql(collation) {
+	switch (collation) {
+		case "binary": return "utf8mb4_bin";
+		case "nocase": return "utf8mb4_general_ci";
+		case "unicode": return "utf8mb4_unicode_ci";
+		default: return "utf8mb4_unicode_ci";
+	}
+}
+/**
+* Maps an Atscript field descriptor to a MySQL column type.
+*
+* Reads `designType`, primitive tags (via `type.type.tags`), and annotations
+* from field metadata to produce the most specific MySQL type.
+*
+* For FK fields, delegates to the target PK's type via `field.fkTargetField`
+* so the FK column type always matches the referenced column.
+*/
+/** Maps integer primitive tags to MySQL integer types. */ function intTypeFromTags(tags, unsigned) {
+	if (tags?.has("int8")) return unsigned ? "TINYINT UNSIGNED" : "TINYINT";
+	if (tags?.has("uint8") || tags?.has("byte")) return "TINYINT UNSIGNED";
+	if (tags?.has("int16")) return unsigned ? "SMALLINT UNSIGNED" : "SMALLINT";
+	if (tags?.has("uint16") || tags?.has("port")) return "SMALLINT UNSIGNED";
+	if (tags?.has("int32")) return unsigned ? "INT UNSIGNED" : "INT";
+	if (tags?.has("uint32")) return "INT UNSIGNED";
+	if (tags?.has("int64")) return unsigned ? "BIGINT UNSIGNED" : "BIGINT";
+	if (tags?.has("uint64")) return "BIGINT UNSIGNED";
+	return unsigned ? "INT UNSIGNED" : "INT";
+}
+function mysqlTypeFromField(field) {
+	if (field.fkTargetField) return mysqlTypeFromField(field.fkTargetField);
+	const tags = field.type?.type?.tags;
+	const metadata = field.type?.metadata;
+	const mysqlTypeOverride = metadata?.get("db.mysql.type");
+	if (mysqlTypeOverride) return mysqlTypeOverride;
+	const unsigned = metadata?.has("db.mysql.unsigned") ?? false;
+	const precision = metadata?.get("db.column.precision");
+	switch (field.designType) {
+		case "number": {
+			if (precision) return `DECIMAL(${precision.precision},${precision.scale})`;
+			if (field.defaultValue?.kind === "fn" && field.defaultValue.fn === "increment") return unsigned ? "BIGINT UNSIGNED" : "BIGINT";
+			if (field.defaultValue?.kind === "fn" && field.defaultValue.fn === "now") return "TIMESTAMP";
+			if (tags?.has("int")) return intTypeFromTags(tags, unsigned);
+			return "DOUBLE";
+		}
+		case "integer": return intTypeFromTags(tags, unsigned);
+		case "decimal": {
+			if (precision) return `DECIMAL(${precision.precision},${precision.scale})`;
+			return "DECIMAL(10,2)";
+		}
+		case "boolean": return "TINYINT(1)";
+		case "string": {
+			if (tags?.has("char")) return "CHAR(1)";
+			const maxLen = metadata?.get("expect.maxLength")?.length;
+			if (maxLen !== undefined && maxLen <= 65535) return `VARCHAR(${maxLen})`;
+			if (maxLen !== undefined && maxLen > 65535) return "LONGTEXT";
+			if (field.isPrimaryKey || field.defaultValue) return "VARCHAR(255)";
+			return "TEXT";
+		}
+		case "json":
+		case "object":
+		case "array": return "JSON";
+		default: {
+			if (field.isPrimaryKey || field.defaultValue) return "VARCHAR(255)";
+			return "TEXT";
+		}
+	}
+}
+function buildCreateTable(table, fields, foreignKeys, options) {
+	const colDefs = [];
+	const primaryKeys = fields.filter((f) => f.isPrimaryKey);
+	for (const field of fields) {
+		if (field.ignored) continue;
+		const sqlType = mysqlTypeFromField(field);
+		let def = `${qi(field.physicalName)} ${sqlType}`;
+		if (options?.incrementFields?.has(field.physicalName)) def += " AUTO_INCREMENT";
+		if (!field.optional && !field.isPrimaryKey && !options?.incrementFields?.has(field.physicalName)) def += " NOT NULL";
+		if (field.defaultValue?.kind === "value") def += ` DEFAULT ${defaultValueToSqlLiteral(field.designType, field.defaultValue.value)}`;
+else if (field.defaultValue?.kind === "fn") {
+			if (field.defaultValue.fn === "uuid") def += " DEFAULT (UUID())";
+else if (field.defaultValue.fn === "now") def += " DEFAULT CURRENT_TIMESTAMP";
+		}
+		const nativeCollate = field.type?.metadata?.get("db.mysql.collate");
+		if (nativeCollate) def += ` COLLATE ${nativeCollate}`;
+else if (field.collate) def += ` COLLATE ${collationToMysql(field.collate)}`;
+		const onUpdate = options?.onUpdateFields?.get(field.physicalName);
+		if (onUpdate) def += ` ON UPDATE ${onUpdate}`;
+		colDefs.push(def);
+	}
+	if (primaryKeys.length === 1) {
+		const pkCol = qi(primaryKeys[0].physicalName);
+		for (let i = 0; i < colDefs.length; i++) if (colDefs[i].startsWith(pkCol)) {
+			colDefs[i] += " PRIMARY KEY";
+			break;
+		}
+	} else if (primaryKeys.length > 1) {
+		const pkCols = primaryKeys.map((pk) => qi(pk.physicalName)).join(", ");
+		colDefs.push(`PRIMARY KEY (${pkCols})`);
+	}
+	if (foreignKeys) for (const fk of foreignKeys.values()) {
+		const localCols = fk.fields.map((f) => qi(f)).join(", ");
+		const targetCols = fk.targetFields.map((f) => qi(f)).join(", ");
+		let constraint = `FOREIGN KEY (${localCols}) REFERENCES ${qi(fk.targetTable)} (${targetCols})`;
+		if (fk.onDelete) constraint += ` ON DELETE ${refActionToSql(fk.onDelete)}`;
+		if (fk.onUpdate) constraint += ` ON UPDATE ${refActionToSql(fk.onUpdate)}`;
+		colDefs.push(constraint);
+	}
+	let sql = `CREATE TABLE IF NOT EXISTS ${quoteTableName(table)} (${colDefs.join(", ")})`;
+	const engine = options?.engine ?? "InnoDB";
+	const charset = options?.charset ?? "utf8mb4";
+	const collation = options?.collation ?? "utf8mb4_unicode_ci";
+	sql += ` ENGINE=${engine} DEFAULT CHARSET=${charset} COLLATE=${collation}`;
+	if (options?.autoIncrementStart !== undefined) sql += ` AUTO_INCREMENT=${options.autoIncrementStart}`;
+	return sql;
+}
+
+//#endregion
+//#region packages/db-mysql/src/filter-builder.ts
+function buildWhere(filter) {
+	return buildWhere$1(mysqlDialect, filter);
+}
+
+//#endregion
+//#region packages/db-mysql/src/mysql-adapter.ts
+function _define_property$1(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+function utcDatetimeToEpochMs(value) {
+	if (typeof value === "number") return value;
+	if (value instanceof Date) return value.getTime();
+	if (typeof value === "string") {
+		const ms = Date.UTC(+value.slice(0, 4), +value.slice(5, 7) - 1, +value.slice(8, 10), +value.slice(11, 13), +value.slice(14, 16), +value.slice(17, 19));
+		return Number.isNaN(ms) ? value : ms;
+	}
+	return value;
+}
+/** Formats epoch ms as 'YYYY-MM-DD HH:MM:SS' in UTC for MySQL TIMESTAMP columns. */ function epochMsToUtcDatetime(ms) {
+	const d = new Date(ms);
+	return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")} ${String(d.getUTCHours()).padStart(2, "0")}:${String(d.getUTCMinutes()).padStart(2, "0")}:${String(d.getUTCSeconds()).padStart(2, "0")}`;
+}
+var MysqlAdapter = class MysqlAdapter extends BaseDbAdapter {
+	/** Schema name for INFORMATION_SCHEMA queries (null falls through to DATABASE()). */ get _schema() {
+		return this._table.schema ?? null;
+	}
+	async _beginTransaction() {
+		const conn = await this.driver.getConnection();
+		await conn.exec("START TRANSACTION");
+		this._log("START TRANSACTION");
+		return conn;
+	}
+	async _commitTransaction(state) {
+		const conn = state;
+		try {
+			this._log("COMMIT");
+			await conn.exec("COMMIT");
+		} finally {
+			conn.release();
+		}
+	}
+	async _rollbackTransaction(state) {
+		const conn = state;
+		try {
+			this._log("ROLLBACK");
+			await conn.exec("ROLLBACK");
+		} finally {
+			conn.release();
+		}
+	}
+	/**
+	* Returns the active executor: dedicated connection if inside a transaction,
+	* otherwise the pool-based driver.
+	*/ _exec() {
+		const txState = this._getTransactionState();
+		return txState ?? this.driver;
+	}
+	/** MySQL InnoDB enforces FK constraints natively. */ supportsNativeForeignKeys() {
+		return true;
+	}
+	prepareId(id, _fieldType) {
+		return id;
+	}
+	supportsNativeValueDefaults() {
+		return true;
+	}
+	nativeDefaultFns() {
+		return MysqlAdapter.NATIVE_DEFAULT_FNS;
+	}
+	onBeforeFlatten(type) {
+		const meta = type.metadata;
+		const engine = meta.get("db.mysql.engine");
+		if (engine) this._engine = engine;
+		const charset = meta.get("db.mysql.charset");
+		if (charset) this._charset = charset;
+		const collate = meta.get("db.mysql.collate");
+		if (collate) this._collation = collate;
+	}
+	onFieldScanned(field, _type, metadata) {
+		if (metadata.has("db.default.increment")) {
+			this._incrementFields.add(field);
+			const startVal = metadata.get("db.default.increment");
+			if (typeof startVal === "number") this._autoIncrementStart = startVal;
+		}
+		const onUpdate = metadata.get("db.mysql.onUpdate");
+		if (onUpdate) this._onUpdateFields.set(field, onUpdate);
+		const vectorMeta = metadata.get("db.search.vector");
+		if (vectorMeta) {
+			const indexName = vectorMeta.indexName || field;
+			this._vectorFields.set(field, {
+				dimensions: vectorMeta.dimensions,
+				similarity: vectorMeta.similarity || "cosine",
+				indexName
+			});
+			const threshold = metadata.get("db.search.vector.threshold");
+			if (threshold !== undefined) this._vectorThresholds.set(indexName, threshold);
+		}
+	}
+	getDesiredTableOptions() {
+		return [
+			{
+				key: "engine",
+				value: this._engine
+			},
+			{
+				key: "charset",
+				value: this._charset
+			},
+			{
+				key: "collation",
+				value: this._collation
+			}
+		];
+	}
+	async getExistingTableOptions() {
+		const row = await this._exec().get(`SELECT ENGINE, TABLE_COLLATION
+       FROM INFORMATION_SCHEMA.TABLES
+       WHERE TABLE_NAME = ? AND TABLE_SCHEMA = COALESCE(?, DATABASE())`, [this._table.tableName, this._schema]);
+		if (!row) return [];
+		const charset = row.TABLE_COLLATION?.split("_")[0] ?? "utf8mb4";
+		return [
+			{
+				key: "engine",
+				value: row.ENGINE ?? "InnoDB"
+			},
+			{
+				key: "charset",
+				value: charset
+			},
+			{
+				key: "collation",
+				value: row.TABLE_COLLATION ?? "utf8mb4_unicode_ci"
+			}
+		];
+	}
+	async applyTableOptions(changes) {
+		const tableName = this.resolveTableName();
+		const clauses = [];
+		for (const change of changes) switch (change.key) {
+			case "engine": {
+				clauses.push(`ENGINE = ${change.newValue}`);
+				break;
+			}
+			case "charset": {
+				clauses.push(`CHARACTER SET = ${change.newValue}`);
+				break;
+			}
+			case "collation": {
+				clauses.push(`COLLATE = ${change.newValue}`);
+				break;
+			}
+		}
+		if (clauses.length > 0) {
+			const ddl = `ALTER TABLE ${quoteTableName(tableName)} ${clauses.join(", ")}`;
+			this._log(ddl);
+			await this._exec().exec(ddl);
+		}
+	}
+	/**
+	* Returns a value formatter for TIMESTAMP-mapped fields.
+	* Number fields with @db.default.now map to MySQL TIMESTAMP — the formatter
+	* converts epoch ms to a UTC datetime string for the wire protocol.
+	*/ formatValue(field) {
+		if (field.designType === "number" && field.defaultValue?.kind === "fn" && field.defaultValue.fn === "now") return {
+			toStorage: (value) => typeof value === "number" ? epochMsToUtcDatetime(value) : value,
+			fromStorage: utcDatetimeToEpochMs
+		};
+		return undefined;
+	}
+	/**
+	* Wraps an async write operation to catch MySQL constraint errors
+	* and rethrow as structured `DbError`.
+	*
+	* MySQL uses numeric error codes:
+	* - 1062 = ER_DUP_ENTRY (unique constraint violation)
+	* - 1451 = ER_ROW_IS_REFERENCED_2 (FK violation on delete)
+	* - 1452 = ER_NO_REFERENCED_ROW_2 (FK violation on insert/update)
+	*/ async _wrapConstraintError(fn) {
+		try {
+			return await fn();
+		} catch (error) {
+			if (error && typeof error === "object" && "errno" in error) {
+				const err = error;
+				if (err.errno === 1062) {
+					const match = err.message?.match(/for key '(?:\w+\.)?(\w+)'/);
+					const field = match?.[1] ?? "";
+					throw new DbError("CONFLICT", [{
+						path: field,
+						message: err.sqlMessage ?? err.message
+					}]);
+				}
+				if (err.errno === 1451 || err.errno === 1452) {
+					const errors = this._mapFkError(err.message);
+					throw new DbError("FK_VIOLATION", errors);
+				}
+			}
+			throw error;
+		}
+	}
+	_mapFkError(message) {
+		const fkMatch = message.match(/FOREIGN KEY \(`(\w+)`\)/);
+		if (fkMatch) {
+			const physicalCol = fkMatch[1];
+			const field = this._table.fieldDescriptors.find((f) => f.physicalName === physicalCol);
+			return [{
+				path: field?.path ?? physicalCol,
+				message
+			}];
+		}
+		return [{
+			path: "",
+			message
+		}];
+	}
+	async insertOne(data) {
+		const { sql, params } = buildInsert$1(this.resolveTableName(), data);
+		this._log(sql, params);
+		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
+		return { insertedId: this._resolveInsertedId(data, result.insertId) };
+	}
+	async insertMany(data) {
+		if (data.length === 0) return {
+			insertedCount: 0,
+			insertedIds: []
+		};
+		return this.withTransaction(async () => {
+			const tableName = this.resolveTableName();
+			const keys = Object.keys(data[0]);
+			const colsClause = keys.map((k) => qi(k)).join(", ");
+			const paramsPerRow = keys.length;
+			const maxRowsPerBatch = paramsPerRow > 0 ? Math.floor(6e4 / paramsPerRow) : data.length;
+			const allIds = [];
+			const rowPlaceholderClause = `(${keys.map(() => "?").join(", ")})`;
+			for (let offset = 0; offset < data.length; offset += maxRowsPerBatch) {
+				const batchEnd = Math.min(offset + maxRowsPerBatch, data.length);
+				const batchSize = batchEnd - offset;
+				const params = [];
+				for (let i = offset; i < batchEnd; i++) {
+					const row = data[i];
+					for (const k of keys) params.push(mysqlDialect.toValue(row[k]));
+				}
+				const valuesClause = Array(batchSize).fill(rowPlaceholderClause).join(", ");
+				const sql = `INSERT INTO ${quoteTableName(tableName)} (${colsClause}) VALUES ${valuesClause}`;
+				this._log(sql, params);
+				const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
+				const firstId = Number(result.insertId);
+				for (let i = 0; i < batchSize; i++) allIds.push(this._resolveInsertedId(data[offset + i], firstId > 0 ? firstId + i : 0));
+			}
+			return {
+				insertedCount: allIds.length,
+				insertedIds: allIds
+			};
+		});
+	}
+	async findOne(query) {
+		const where = buildWhere(query.filter);
+		const controls = {
+			...query.controls,
+			$limit: 1
+		};
+		const { sql, params } = buildSelect$1(this.resolveTableName(), where, controls);
+		this._log(sql, params);
+		return this._exec().get(sql, params);
+	}
+	async findMany(query) {
+		const where = buildWhere(query.filter);
+		const { sql, params } = buildSelect$1(this.resolveTableName(), where, query.controls);
+		this._log(sql, params);
+		return this._exec().all(sql, params);
+	}
+	async count(query) {
+		const where = buildWhere(query.filter);
+		const tableName = this.resolveTableName();
+		const sql = `SELECT COUNT(*) as cnt FROM ${quoteTableName(tableName)} WHERE ${where.sql}`;
+		this._log(sql, where.params);
+		const row = await this._exec().get(sql, where.params);
+		return row?.cnt ?? 0;
+	}
+	async aggregate(query) {
+		const where = buildWhere(query.filter);
+		const tableName = this.resolveTableName();
+		if (query.controls.$count) {
+			const { sql: sql$1, params: params$1 } = buildAggregateCount$1(tableName, where, query.controls);
+			this._log(sql$1, params$1);
+			const row = await this._exec().get(sql$1, params$1);
+			return [{ count: row?.count ?? 0 }];
+		}
+		const { sql, params } = buildAggregateSelect$1(tableName, where, query.controls);
+		this._log(sql, params);
+		return this._exec().all(sql, params);
+	}
+	async updateOne(filter, data) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildUpdate$1(this.resolveTableName(), data, where, 1);
+		this._log(sql, params);
+		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
+		return {
+			matchedCount: result.affectedRows,
+			modifiedCount: result.changedRows
+		};
+	}
+	async updateMany(filter, data) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildUpdate$1(this.resolveTableName(), data, where);
+		this._log(sql, params);
+		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
+		return {
+			matchedCount: result.affectedRows,
+			modifiedCount: result.changedRows
+		};
+	}
+	async replaceOne(filter, data) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildUpdate$1(this.resolveTableName(), data, where, 1);
+		this._log(sql, params);
+		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
+		return {
+			matchedCount: result.affectedRows,
+			modifiedCount: result.changedRows
+		};
+	}
+	async replaceMany(filter, data) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildUpdate$1(this.resolveTableName(), data, where);
+		this._log(sql, params);
+		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
+		return {
+			matchedCount: result.affectedRows,
+			modifiedCount: result.changedRows
+		};
+	}
+	async deleteOne(filter) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildDelete$1(this.resolveTableName(), where, 1);
+		this._log(sql, params);
+		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
+		return { deletedCount: result.affectedRows };
+	}
+	async deleteMany(filter) {
+		const where = buildWhere(filter);
+		const { sql, params } = buildDelete$1(this.resolveTableName(), where);
+		this._log(sql, params);
+		const result = await this._wrapConstraintError(() => this._exec().run(sql, params));
+		return { deletedCount: result.affectedRows };
+	}
+	async ensureTable() {
+		if (this._supportsVector === undefined && this._vectorFields.size > 0) await this._detectVectorSupport();
+		if (this._table instanceof AtscriptDbView) return this._ensureView();
+		const sql = buildCreateTable(this.resolveTableName(), this._table.fieldDescriptors, this._table.foreignKeys, {
+			engine: this._engine,
+			charset: this._charset,
+			collation: this._collation,
+			autoIncrementStart: this._autoIncrementStart,
+			incrementFields: this._incrementFields,
+			onUpdateFields: this._onUpdateFields
+		});
+		this._log(sql);
+		await this._exec().exec(sql);
+	}
+	async _ensureView() {
+		const view = this._table;
+		const sql = buildCreateView$1(this.resolveTableName(), view.viewPlan, view.getViewColumnMappings(), (ref) => view.resolveFieldRef(ref, qi));
+		this._log(sql);
+		await this._exec().exec(sql);
+	}
+	async getExistingColumns() {
+		return this.getExistingColumnsForTable(this._table.tableName);
+	}
+	async getExistingColumnsForTable(tableName) {
+		const schema = this._schema;
+		const rows = await this._exec().all(`SELECT COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, COLUMN_DEFAULT
+       FROM INFORMATION_SCHEMA.COLUMNS
+       WHERE TABLE_NAME = ? AND TABLE_SCHEMA = COALESCE(?, DATABASE())
+       ORDER BY ORDINAL_POSITION`, [tableName, schema]);
+		return rows.map((r) => ({
+			name: r.COLUMN_NAME,
+			type: r.COLUMN_TYPE.toUpperCase(),
+			notnull: r.IS_NULLABLE === "NO",
+			pk: r.COLUMN_KEY === "PRI",
+			dflt_value: normalizeMysqlDefault(r.COLUMN_DEFAULT)
+		}));
+	}
+	async syncColumns(diff) {
+		const tableName = this.resolveTableName();
+		const added = [];
+		const renamed = [];
+		for (const { field, oldName } of diff.renamed ?? []) {
+			const ddl = `ALTER TABLE ${quoteTableName(tableName)} RENAME COLUMN ${qi(oldName)} TO ${qi(field.physicalName)}`;
+			this._log(ddl);
+			await this._exec().exec(ddl);
+			renamed.push(field.physicalName);
+		}
+		for (const field of diff.added) {
+			const sqlType = this.typeMapper(field);
+			let ddl = `ALTER TABLE ${quoteTableName(tableName)} ADD COLUMN ${qi(field.physicalName)} ${sqlType}`;
+			if (!field.optional && !field.isPrimaryKey) ddl += " NOT NULL";
+			if (field.defaultValue?.kind === "value") ddl += ` DEFAULT ${defaultValueToSqlLiteral(field.designType, field.defaultValue.value)}`;
+else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValueForType(field.designType)}`;
+			if (field.collate) {
+				const nativeCollate = field.type?.metadata?.get("db.mysql.collate");
+				ddl += ` COLLATE ${nativeCollate ?? collationToMysql(field.collate)}`;
+			}
+			this._log(ddl);
+			await this._exec().exec(ddl);
+			added.push(field.physicalName);
+		}
+		for (const { field } of diff.typeChanged ?? []) {
+			const sqlType = this.typeMapper(field);
+			let ddl = `ALTER TABLE ${quoteTableName(tableName)} MODIFY COLUMN ${qi(field.physicalName)} ${sqlType}`;
+			if (!field.optional && !field.isPrimaryKey) ddl += " NOT NULL";
+			this._log(ddl);
+			await this._exec().exec(ddl);
+		}
+		for (const { field } of diff.nullableChanged ?? []) {
+			const sqlType = this.typeMapper(field);
+			const nullability = field.optional ? "NULL" : "NOT NULL";
+			const ddl = `ALTER TABLE ${quoteTableName(tableName)} MODIFY COLUMN ${qi(field.physicalName)} ${sqlType} ${nullability}`;
+			this._log(ddl);
+			await this._exec().exec(ddl);
+		}
+		for (const { field } of diff.defaultChanged ?? []) {
+			const sqlType = this.typeMapper(field);
+			let ddl = `ALTER TABLE ${quoteTableName(tableName)} MODIFY COLUMN ${qi(field.physicalName)} ${sqlType}`;
+			if (!field.optional && !field.isPrimaryKey) ddl += " NOT NULL";
+			if (field.defaultValue?.kind === "value") ddl += ` DEFAULT ${defaultValueToSqlLiteral(field.designType, field.defaultValue.value)}`;
+else if (field.defaultValue?.kind === "fn") ddl += ` DEFAULT ${field.defaultValue.fn === "now" ? "CURRENT_TIMESTAMP" : field.defaultValue.fn === "uuid" ? "(UUID())" : `(${field.defaultValue.fn}())`}`;
+else ddl += " DEFAULT NULL";
+			this._log(ddl);
+			await this._exec().exec(ddl);
+		}
+		return {
+			added,
+			renamed
+		};
+	}
+	async recreateTable() {
+		const tableName = this.resolveTableName();
+		const tempName = `${this._table.tableName}__tmp_${Date.now()}`;
+		await this._exec().exec("SET FOREIGN_KEY_CHECKS = 0");
+		try {
+			const createSql = buildCreateTable(tempName, this._table.fieldDescriptors, this._table.foreignKeys, {
+				engine: this._engine,
+				charset: this._charset,
+				collation: this._collation,
+				autoIncrementStart: this._autoIncrementStart,
+				incrementFields: this._incrementFields,
+				onUpdateFields: this._onUpdateFields
+			});
+			this._log(createSql);
+			await this._exec().exec(createSql);
+			const oldCols = (await this.getExistingColumns()).map((c) => c.name);
+			const newCols = this._table.fieldDescriptors.filter((f) => !f.ignored).map((f) => f.physicalName);
+			const oldColSet = new Set(oldCols);
+			const commonCols = newCols.filter((c) => oldColSet.has(c));
+			if (commonCols.length > 0) {
+				const fieldsByName = new Map(this._table.fieldDescriptors.map((f) => [f.physicalName, f]));
+				const colNames = commonCols.map((c) => qi(c)).join(", ");
+				const selectExprs = commonCols.map((c) => {
+					const field = fieldsByName.get(c);
+					if (field && !field.optional && !field.isPrimaryKey) {
+						const fallback = field.defaultValue?.kind === "value" ? defaultValueToSqlLiteral(field.designType, field.defaultValue.value) : defaultValueForType(field.designType);
+						return `COALESCE(${qi(c)}, ${fallback}) AS ${qi(c)}`;
+					}
+					return qi(c);
+				}).join(", ");
+				const copySql = `INSERT INTO ${qi(tempName)} (${colNames}) SELECT ${selectExprs} FROM ${quoteTableName(tableName)}`;
+				this._log(copySql);
+				await this._exec().exec(copySql);
+			}
+			await this._exec().exec(`DROP TABLE IF EXISTS ${quoteTableName(tableName)}`);
+			await this._exec().exec(`RENAME TABLE ${qi(tempName)} TO ${quoteTableName(tableName)}`);
+		} finally {
+			await this._exec().exec("SET FOREIGN_KEY_CHECKS = 1");
+		}
+	}
+	async dropTable() {
+		const ddl = `DROP TABLE IF EXISTS ${quoteTableName(this.resolveTableName())}`;
+		this._log(ddl);
+		const conn = await this.driver.getConnection();
+		await conn.exec("SET FOREIGN_KEY_CHECKS = 0");
+		try {
+			await conn.exec(ddl);
+		} finally {
+			await conn.exec("SET FOREIGN_KEY_CHECKS = 1");
+			conn.release();
+		}
+	}
+	async dropColumns(columns) {
+		const tableName = this.resolveTableName();
+		const drops = columns.map((col) => `DROP COLUMN ${qi(col)}`).join(", ");
+		const ddl = `ALTER TABLE ${quoteTableName(tableName)} ${drops}`;
+		this._log(ddl);
+		await this._exec().exec(ddl);
+	}
+	async dropTableByName(tableName) {
+		const ddl = `DROP TABLE IF EXISTS ${quoteTableName(tableName)}`;
+		this._log(ddl);
+		const conn = await this.driver.getConnection();
+		await conn.exec("SET FOREIGN_KEY_CHECKS = 0");
+		try {
+			await conn.exec(ddl);
+		} finally {
+			await conn.exec("SET FOREIGN_KEY_CHECKS = 1");
+			conn.release();
+		}
+	}
+	async dropViewByName(viewName) {
+		const ddl = `DROP VIEW IF EXISTS ${quoteTableName(viewName)}`;
+		this._log(ddl);
+		await this._exec().exec(ddl);
+	}
+	async renameTable(oldName) {
+		const newName = this.resolveTableName();
+		const ddl = `RENAME TABLE ${quoteTableName(oldName)} TO ${quoteTableName(newName)}`;
+		this._log(ddl);
+		await this._exec().exec(ddl);
+	}
+	typeMapper(field) {
+		if (this._vectorFields.has(field.path)) {
+			const vec = this._vectorFields.get(field.path);
+			return this._supportsVector ? `VECTOR(${vec.dimensions})` : "JSON";
+		}
+		return mysqlTypeFromField(field);
+	}
+	async syncIndexes() {
+		const tableName = this._table.tableName;
+		const schema = this._schema;
+		const stringFields = new Set(this._table.fieldDescriptors.filter((f) => f.designType === "string").map((f) => f.physicalName));
+		await this.syncIndexesWithDiff({
+			listExisting: async () => this._exec().all(`SELECT DISTINCT INDEX_NAME as name FROM INFORMATION_SCHEMA.STATISTICS
+           WHERE TABLE_NAME = ? AND TABLE_SCHEMA = COALESCE(?, DATABASE())`, [tableName, schema]),
+			createIndex: async (index) => {
+				const unique = index.type === "unique" ? "UNIQUE " : "";
+				const fulltext = index.type === "fulltext" ? "FULLTEXT " : "";
+				const isFulltext = index.type === "fulltext";
+				const cols = index.fields.map((f) => {
+					const col = qi(f.name);
+					const prefix = !isFulltext && stringFields.has(f.name) ? "(255)" : "";
+					const order = isFulltext ? "" : ` ${f.sort === "desc" ? "DESC" : "ASC"}`;
+					return `${col}${prefix}${order}`;
+				}).join(", ");
+				const sql = `CREATE ${fulltext}${unique}INDEX ${qi(index.key)} ON ${quoteTableName(this.resolveTableName())} (${cols})`;
+				this._log(sql);
+				await this._exec().exec(sql);
+			},
+			dropIndex: async (name) => {
+				const sql = `DROP INDEX ${qi(name)} ON ${quoteTableName(this.resolveTableName())}`;
+				this._log(sql);
+				await this._exec().exec(sql);
+			}
+		});
+	}
+	async syncForeignKeys() {
+		const existingByName = await this._getExistingFkConstraints();
+		const desiredFkKeys = new Set();
+		for (const fk of this._table.foreignKeys.values()) desiredFkKeys.add([...fk.fields].sort().join(","));
+		for (const [constraintName, columns] of existingByName) {
+			const key = columns.sort().join(",");
+			if (!desiredFkKeys.has(key)) {
+				const ddl = `ALTER TABLE ${quoteTableName(this.resolveTableName())} DROP FOREIGN KEY ${qi(constraintName)}`;
+				this._log(ddl);
+				await this._exec().exec(ddl);
+			}
+		}
+		const existingKeys = new Set([...existingByName.values()].map((cols) => cols.sort().join(",")));
+		for (const fk of this._table.foreignKeys.values()) {
+			const key = [...fk.fields].sort().join(",");
+			if (!existingKeys.has(key)) {
+				const localCols = fk.fields.map((f) => qi(f)).join(", ");
+				const targetCols = fk.targetFields.map((f) => qi(f)).join(", ");
+				let ddl = `ALTER TABLE ${quoteTableName(this.resolveTableName())} ADD FOREIGN KEY (${localCols}) REFERENCES ${qi(fk.targetTable)} (${targetCols})`;
+				if (fk.onDelete) ddl += ` ON DELETE ${refActionToSql(fk.onDelete)}`;
+				if (fk.onUpdate) ddl += ` ON UPDATE ${refActionToSql(fk.onUpdate)}`;
+				this._log(ddl);
+				await this._exec().exec(ddl);
+			}
+		}
+	}
+	async dropForeignKeys(fkFieldKeys) {
+		if (fkFieldKeys.length === 0) return;
+		const keySet = new Set(fkFieldKeys);
+		const existingByName = await this._getExistingFkConstraints();
+		for (const [constraintName, cols] of existingByName) {
+			const key = cols.sort().join(",");
+			if (keySet.has(key)) {
+				const ddl = `ALTER TABLE ${quoteTableName(this.resolveTableName())} DROP FOREIGN KEY ${qi(constraintName)}`;
+				this._log(ddl);
+				await this._exec().exec(ddl);
+			}
+		}
+	}
+	/** Queries INFORMATION_SCHEMA for existing FK constraints, grouped by constraint name → column names. */ async _getExistingFkConstraints() {
+		const rows = await this._exec().all(`SELECT kcu.CONSTRAINT_NAME, kcu.COLUMN_NAME
+       FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+       WHERE kcu.TABLE_NAME = ? AND kcu.TABLE_SCHEMA = COALESCE(?, DATABASE())
+         AND kcu.REFERENCED_TABLE_NAME IS NOT NULL`, [this._table.tableName, this._schema]);
+		const byName = new Map();
+		for (const row of rows) {
+			let cols = byName.get(row.CONSTRAINT_NAME);
+			if (!cols) {
+				cols = [];
+				byName.set(row.CONSTRAINT_NAME, cols);
+			}
+			cols.push(row.COLUMN_NAME);
+		}
+		return byName;
+	}
+	getSearchIndexes() {
+		const indexes = [];
+		for (const index of this._table.indexes.values()) if (index.type === "fulltext") indexes.push({
+			name: index.key,
+			description: `FULLTEXT index on ${index.fields.map((f) => f.name).join(", ")}`,
+			type: "text"
+		});
+		for (const [field, vec] of this._vectorFields) indexes.push({
+			name: vec.indexName,
+			description: `VECTOR(${vec.dimensions}) on ${field}, ${vec.similarity}`,
+			type: "vector"
+		});
+		return indexes;
+	}
+	async search(text, query, indexName) {
+		const combinedWhere = this._buildSearchWhere(text, query, indexName);
+		const { sql, params } = buildSelect$1(this.resolveTableName(), combinedWhere, query.controls);
+		this._log(sql, params);
+		return this._exec().all(sql, params);
+	}
+	async searchWithCount(text, query, indexName) {
+		const combinedWhere = this._buildSearchWhere(text, query, indexName);
+		const tableName = this.resolveTableName();
+		const selectPromise = (async () => {
+			const { sql, params } = buildSelect$1(tableName, combinedWhere, query.controls);
+			this._log(sql, params);
+			return this._exec().all(sql, params);
+		})();
+		const countPromise = (async () => {
+			const sql = `SELECT COUNT(*) as cnt FROM ${quoteTableName(tableName)} WHERE ${combinedWhere.sql}`;
+			this._log(sql, combinedWhere.params);
+			const row = await this._exec().get(sql, combinedWhere.params);
+			return row?.cnt ?? 0;
+		})();
+		const [data, count] = await Promise.all([selectPromise, countPromise]);
+		return {
+			data,
+			count
+		};
+	}
+	_buildSearchWhere(text, query, indexName) {
+		const fulltextIndex = this._getFulltextIndex(indexName);
+		if (!fulltextIndex) throw new Error("No FULLTEXT index found for search");
+		const matchCols = fulltextIndex.fields.map((f) => qi(f.name)).join(", ");
+		const where = buildWhere(query.filter);
+		const matchClause = `MATCH(${matchCols}) AGAINST(? IN NATURAL LANGUAGE MODE)`;
+		return {
+			sql: where.sql === "1=1" ? matchClause : `${where.sql} AND ${matchClause}`,
+			params: [...where.params, text]
+		};
+	}
+	_getFulltextIndex(indexName) {
+		for (const index of this._table.indexes.values()) if (index.type === "fulltext") {
+			if (!indexName || index.key === indexName) return index;
+		}
+		return undefined;
+	}
+	/**
+	* Detects native VECTOR type support by inspecting the server version.
+	* MySQL 9.0+ supports the VECTOR column type natively.
+	* Caches the result for the lifetime of this adapter instance.
+	*/ async _detectVectorSupport() {
+		if (this._supportsVector !== undefined) return this._supportsVector;
+		try {
+			const row = await this.driver.get("SELECT VERSION() as v", []);
+			if (row?.v) {
+				const major = Number.parseInt(row.v, 10);
+				this._supportsVector = !Number.isNaN(major) && major >= 9;
+			} else this._supportsVector = false;
+		} catch {
+			this._supportsVector = false;
+		}
+		return this._supportsVector;
+	}
+	isVectorSearchable() {
+		return this._supportsVector === true && this._vectorFields.size > 0;
+	}
+	async vectorSearch(vector, query, indexName) {
+		await this._detectVectorSupport();
+		if (!this._supportsVector) throw new Error("Vector search requires MySQL 9.0+");
+		const { sql, params } = this._buildVectorSearchQuery(vector, query, indexName);
+		this._log(sql, params);
+		return this._exec().all(sql, params);
+	}
+	async vectorSearchWithCount(vector, query, indexName) {
+		await this._detectVectorSupport();
+		if (!this._supportsVector) throw new Error("Vector search requires MySQL 9.0+");
+		const { sql, params } = this._buildVectorSearchQuery(vector, query, indexName);
+		const { sql: countSql, params: countParams } = this._buildVectorSearchCountQuery(vector, query, indexName);
+		this._log(sql, params);
+		this._log(countSql, countParams);
+		const [data, countRow] = await Promise.all([this._exec().all(sql, params), this._exec().get(countSql, countParams)]);
+		return {
+			data,
+			count: countRow?.cnt ?? 0
+		};
+	}
+	/** Resolves vector field and computes shared context for vector search SQL builders. */ _prepareVectorSearch(vector, query, indexName) {
+		let field;
+		let vec;
+		if (indexName) {
+			let found = false;
+			for (const [f, v] of this._vectorFields) if (v.indexName === indexName) {
+				field = f;
+				vec = v;
+				found = true;
+				break;
+			}
+			if (!found) throw new Error(`Vector index "${indexName}" not found`);
+		} else {
+			const first = this._vectorFields.entries().next();
+			if (first.done) throw new Error("No vector fields defined");
+			field = first.value[0];
+			vec = first.value[1];
+		}
+		const distanceFn = similarityToMysqlFn(vec.similarity);
+		const where = buildWhere(query.filter);
+		const controls = query.controls || {};
+		const threshold = this._resolveVectorThreshold(controls, vec.indexName);
+		return {
+			field,
+			vec,
+			distanceFn,
+			where,
+			controls,
+			threshold,
+			tableName: this.resolveTableName(),
+			vectorStr: vectorToString(vector)
+		};
+	}
+	_buildVectorSearchQuery(vector, query, indexName) {
+		const ctx = this._prepareVectorSearch(vector, query, indexName);
+		const inner = `SELECT *, ${ctx.distanceFn}(${qi(ctx.field)}, STRING_TO_VECTOR(?)) AS _distance FROM ${quoteTableName(ctx.tableName)} WHERE ${ctx.where.sql}`;
+		const params = [ctx.vectorStr, ...ctx.where.params];
+		let sql = `SELECT * FROM (${inner}) _v`;
+		if (ctx.threshold !== undefined) {
+			sql += ` WHERE _distance <= ?`;
+			params.push(2 * (1 - ctx.threshold));
+		}
+		sql += ` ORDER BY _distance ASC`;
+		if (ctx.controls.$skip) sql += ` LIMIT ${ctx.controls.$limit || 1e3} OFFSET ${ctx.controls.$skip}`;
+else sql += ` LIMIT ${ctx.controls.$limit || 20}`;
+		return {
+			sql,
+			params
+		};
+	}
+	_buildVectorSearchCountQuery(vector, query, indexName) {
+		const ctx = this._prepareVectorSearch(vector, query, indexName);
+		const inner = `SELECT ${ctx.distanceFn}(${qi(ctx.field)}, STRING_TO_VECTOR(?)) AS _distance FROM ${quoteTableName(ctx.tableName)} WHERE ${ctx.where.sql}`;
+		const params = [ctx.vectorStr, ...ctx.where.params];
+		let sql = `SELECT COUNT(*) AS cnt FROM (${inner}) _v`;
+		if (ctx.threshold !== undefined) {
+			sql += ` WHERE _distance <= ?`;
+			params.push(2 * (1 - ctx.threshold));
+		}
+		return {
+			sql,
+			params
+		};
+	}
+	/** Resolves threshold: query-time $threshold > schema-level @db.search.vector.threshold. */ _resolveVectorThreshold(controls, indexName) {
+		const queryThreshold = controls.$threshold;
+		if (queryThreshold !== undefined) return queryThreshold;
+		return this._vectorThresholds.get(indexName);
+	}
+	constructor(driver) {
+		super(), _define_property$1(this, "driver", void 0), _define_property$1(this, "supportsColumnModify", void 0), _define_property$1(this, "_engine", void 0), _define_property$1(this, "_charset", void 0), _define_property$1(this, "_collation", void 0), _define_property$1(this, "_autoIncrementStart", void 0), _define_property$1(this, "_incrementFields", void 0), _define_property$1(this, "_onUpdateFields", void 0), _define_property$1(this, "_supportsVector", void 0), _define_property$1(this, "_vectorFields", void 0), _define_property$1(this, "_vectorThresholds", void 0), this.driver = driver, this.supportsColumnModify = true, this._engine = "InnoDB", this._charset = "utf8mb4", this._collation = "utf8mb4_unicode_ci", this._incrementFields = new Set(), this._onUpdateFields = new Map(), this._vectorFields = new Map(), this._vectorThresholds = new Map();
+	}
+};
+_define_property$1(MysqlAdapter, "NATIVE_DEFAULT_FNS", new Set(["now", "increment"]));
+/**
+* Normalizes MySQL INFORMATION_SCHEMA.COLUMNS.COLUMN_DEFAULT values
+* to match the format produced by `serializeDefaultValue()`.
+*
+* MySQL stores expression defaults as raw SQL (e.g., `CURRENT_TIMESTAMP`,
+* `uuid()`), but the diff engine compares against serialized form (`fn:now`,
+* `fn:uuid`). Without normalization, every table with function defaults
+* produces phantom ALTER diffs on re-plan.
+*/ function normalizeMysqlDefault(value) {
+	if (value === null) return undefined;
+	const lower = value.toLowerCase();
+	if (lower === "current_timestamp" || lower === "current_timestamp()") return "fn:now";
+	if (lower === "uuid()") return "fn:uuid";
+	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1).replace(/''/g, "'");
+	return value;
+}
+/** Maps generic similarity metric to MySQL 9+ distance function name. */ function similarityToMysqlFn(similarity) {
+	switch (similarity) {
+		case "euclidean": return "VEC_DISTANCE_EUCLIDEAN";
+		case "dotProduct": return "VEC_DISTANCE_DOT";
+		default: return "VEC_DISTANCE_COSINE";
+	}
+}
+/** Formats a number[] vector as MySQL's STRING_TO_VECTOR input: '[1.0, 2.0, ...]'. */ function vectorToString(vector) {
+	return `[${vector.join(",")}]`;
+}
+
+//#endregion
+//#region packages/db-mysql/src/mysql2-driver.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+/** mysql2 rejects `undefined` in bind arrays — coerce to `null`. */ function sanitizeParams(params) {
+	if (!params) return [];
+	return params.map((v) => v === undefined ? null : v);
+}
+/**
+* Custom type-casting for mysql2 result columns to maintain cross-adapter consistency.
+*
+* - TIMESTAMP/DATETIME → epoch milliseconds (number) instead of Date objects
+* - DECIMAL/NEWDECIMAL → number instead of string
+*/ function atscriptTypeCast(field, next) {
+	if (field.type === "TIMESTAMP" || field.type === "DATETIME") {
+		const str = field.string();
+		if (str === null) return null;
+		return utcDatetimeToEpochMs(str);
+	}
+	if (field.type === "NEWDECIMAL" || field.type === "DECIMAL") {
+		const str = field.string();
+		return str === null ? null : Number(str);
+	}
+	return next();
+}
+var Mysql2Driver = class {
+	getPool() {
+		return this.pool || this.poolInit;
+	}
+	async run(sql, params) {
+		const pool = await this.getPool();
+		const [result] = await pool.query(sql, sanitizeParams(params));
+		const header = result;
+		return {
+			affectedRows: header.affectedRows ?? 0,
+			insertId: header.insertId ?? 0,
+			changedRows: header.changedRows ?? 0
+		};
+	}
+	async all(sql, params) {
+		const pool = await this.getPool();
+		const [rows] = await pool.query(sql, sanitizeParams(params));
+		return rows;
+	}
+	async get(sql, params) {
+		const pool = await this.getPool();
+		const [rows] = await pool.query(sql, sanitizeParams(params));
+		return rows[0] ?? null;
+	}
+	async exec(sql) {
+		const pool = await this.getPool();
+		await pool.query(sql);
+	}
+	async getConnection() {
+		const pool = await this.getPool();
+		const conn = await pool.getConnection();
+		return {
+			async run(sql, params) {
+				const [result] = await conn.query(sql, sanitizeParams(params));
+				const header = result;
+				return {
+					affectedRows: header.affectedRows ?? 0,
+					insertId: header.insertId ?? 0,
+					changedRows: header.changedRows ?? 0
+				};
+			},
+			async all(sql, params) {
+				const [rows] = await conn.query(sql, sanitizeParams(params));
+				return rows;
+			},
+			async get(sql, params) {
+				const [rows] = await conn.query(sql, sanitizeParams(params));
+				return rows[0] ?? null;
+			},
+			async exec(sql) {
+				await conn.query(sql);
+			},
+			release() {
+				conn.release();
+			}
+		};
+	}
+	async close() {
+		const pool = await this.getPool();
+		await pool.end();
+	}
+	constructor(poolOrConfig) {
+		_define_property(this, "pool", void 0);
+		_define_property(this, "poolInit", void 0);
+		if (typeof poolOrConfig === "object" && "execute" in poolOrConfig) this.pool = poolOrConfig;
+else this.poolInit = import("mysql2/promise").then((mysql) => {
+			if (typeof poolOrConfig === "string") this.pool = mysql.createPool({
+				uri: poolOrConfig,
+				timezone: "+00:00",
+				supportBigNumbers: true,
+				bigNumberStrings: false,
+				typeCast: atscriptTypeCast
+			});
+else this.pool = mysql.createPool({
+				...poolOrConfig,
+				timezone: "+00:00",
+				supportBigNumbers: true,
+				bigNumberStrings: false,
+				typeCast: atscriptTypeCast
+			});
+			return this.pool;
+		});
+	}
+};
+
+//#endregion
+//#region packages/db-mysql/src/plugin/annotations.ts
+const annotations = {
+	engine: new AnnotationSpec({
+		description: "Specifies the MySQL storage engine.\n\n**Default:** `\"InnoDB\"`\n\n```atscript\n@db.mysql.engine \"MyISAM\"\nexport interface Logs { ... }\n```",
+		nodeType: ["interface"],
+		multiple: false,
+		argument: {
+			name: "engine",
+			type: "string",
+			values: [
+				"InnoDB",
+				"MyISAM",
+				"MEMORY",
+				"CSV",
+				"ARCHIVE"
+			],
+			description: "MySQL storage engine name."
+		}
+	}),
+	charset: new AnnotationSpec({
+		description: "Specifies the character set for the table or column.\n\n**Default:** `\"utf8mb4\"`\n\n```atscript\n@db.mysql.charset \"latin1\"\nexport interface Legacy { ... }\n```",
+		nodeType: ["interface", "prop"],
+		multiple: false,
+		argument: {
+			name: "charset",
+			type: "string",
+			values: [
+				"utf8mb4",
+				"utf8",
+				"latin1",
+				"ascii",
+				"binary"
+			],
+			description: "MySQL character set name."
+		}
+	}),
+	collate: new AnnotationSpec({
+		description: "Specifies a native MySQL collation (overrides portable `@db.column.collate`).\n\n```atscript\n@db.mysql.collate \"utf8mb4_turkish_ci\"\nname: string\n```",
+		nodeType: ["interface", "prop"],
+		multiple: false,
+		argument: {
+			name: "collation",
+			type: "string",
+			description: "Native MySQL collation name (e.g., \"utf8mb4_turkish_ci\")."
+		}
+	}),
+	unsigned: new AnnotationSpec({
+		description: "Adds the UNSIGNED modifier to an integer column.\n\n```atscript\n@db.mysql.unsigned\nage: number.int\n```",
+		nodeType: ["prop"],
+		multiple: false
+	}),
+	type: new AnnotationSpec({
+		description: "Overrides the native MySQL column type.\n\n```atscript\n@db.mysql.type \"MEDIUMTEXT\"\nbio: string\n```",
+		nodeType: ["prop"],
+		multiple: false,
+		argument: {
+			name: "type",
+			type: "string",
+			description: "Native MySQL column type (e.g., \"MEDIUMTEXT\", \"TINYTEXT\")."
+		}
+	}),
+	onUpdate: new AnnotationSpec({
+		description: "Sets the MySQL ON UPDATE clause for a column.\n\n```atscript\n@db.mysql.onUpdate \"CURRENT_TIMESTAMP\"\nupdatedAt: number.timestamp\n```",
+		nodeType: ["prop"],
+		multiple: false,
+		argument: {
+			name: "expression",
+			type: "string",
+			values: ["CURRENT_TIMESTAMP"],
+			description: "Expression to evaluate on row update."
+		}
+	})
+};
+
+//#endregion
+//#region packages/db-mysql/src/plugin/index.ts
+const MysqlPlugin = () => ({
+	name: "mysql",
+	config() {
+		return { annotations: { db: { mysql: annotations } } };
+	}
+});
+
+//#endregion
+//#region packages/db-mysql/src/index.ts
+function createAdapter(uri, options) {
+	const driver = new Mysql2Driver({
+		uri,
+		...options
+	});
+	return new DbSpace(() => new MysqlAdapter(driver));
+}
+
+//#endregion
+export { Mysql2Driver, MysqlAdapter, MysqlPlugin, buildWhere, createAdapter };