@relq/orm 0.1.3 → 0.1.5

package/dist/esm/core/shared/table-accessor.js

@@ -1,4 +1,4 @@
-import { ConnectedQueryBuilder } from "../helpers/ConnectedQueryBuilder.js";
+import { ConnectedQueryBuilder } from "../../pg/helpers/ConnectedQueryBuilder.js";
 export function createTableAccessor(relq, schema) {
     const tableFunction = (tableName) => {
         return new ConnectedQueryBuilder(tableName, relq);

package/dist/esm/core/shared/where.js

@@ -0,0 +1,12 @@
+import { ConditionCollector } from "../../pg/condition/condition-collector.js";
+import { MysqlConditionCollector } from "../../mysql/condition/condition-collector.js";
+export function Where(tableDefinition) {
+    if (tableDefinition.$family === 'mysql') {
+        const collector = new MysqlConditionCollector();
+        collector._tableName = tableDefinition.$name;
+        return collector;
+    }
+    const collector = new ConditionCollector();
+    collector._tableName = tableDefinition.$name;
+    return collector;
+}

package/dist/esm/index.js

@@ -1,7 +1,19 @@
 export { Relq } from "./core/relq-client.js";
-export { RelqPostgres } from "./core/pg-family/pg-client/index.js";
-export { RelqNile } from "./core/pg-family/nile-client/index.js";
-export { RelqDsql } from "./core/pg-family/dsql-client/index.js";
-export { RelqCockroachDB } from "./core/pg-family/cockroachdb-client/index.js";
-export { RelqError, RelqConnectionError, RelqQueryError, RelqTransactionError, RelqConfigError, RelqTimeoutError, RelqPoolError, isRelqError, isRelqConnectionError, isRelqQueryError, } from "./shared/errors/relq-errors.js";
+export { RelqPostgres } from "./pg/clients/pg-client/index.js";
+export { RelqNile } from "./pg/clients/nile-client/index.js";
+export { RelqDsql } from "./pg/clients/dsql-client/index.js";
+export { RelqCockroachDB } from "./pg/clients/cockroachdb-client/index.js";
+export { RelqSupabase } from "./pg/clients/supabase-client/index.js";
+export { RelqNeon } from "./pg/clients/neon-client/index.js";
+export { RelqAlloyDB } from "./pg/clients/alloydb-client/index.js";
+export { RelqAurora } from "./pg/clients/aurora-client/index.js";
+export { RelqYugabyteDB } from "./pg/clients/yugabytedb-client/index.js";
+export { RelqCitus } from "./pg/clients/citus-client/index.js";
+export { RelqTimescale } from "./pg/clients/timescale-client/index.js";
+export { RelqMysql } from "./mysql/clients/mysql-client/index.js";
+export { RelqMariaDB } from "./mysql/clients/mariadb-client/index.js";
+export { RelqPlanetScale } from "./mysql/clients/planetscale-client/index.js";
+export { RelqError, RelqConnectionError, RelqQueryError, RelqTransactionError, RelqConfigError, RelqTimeoutError, RelqPoolError, RelqConstraintError, RelqSchemaError, RelqDataError, RelqLockError, RelqBuilderError, isRelqError, isRelqConnectionError, isRelqQueryError, isRelqConstraintError, isRelqSchemaError, isRelqDataError, isRelqLockError, isRelqBuilderError, getOriginalError, } from "./shared/errors/relq-errors.js";
+export { Where } from "./core/shared/where.js";
+export { sql } from "./pg/raw/sql-template.js";
 export { format as pg_format } from "./utils/index.js";

package/dist/esm/mysql/clients/index.js

@@ -0,0 +1,5 @@
+export { RelqMysql, MYSQL_CAPABILITIES } from "./mysql-client/index.js";
+export { RelqMariaDB, MARIADB_CAPABILITIES } from "./mariadb-client/index.js";
+export { RelqPlanetScale, PLANETSCALE_CAPABILITIES } from "./planetscale-client/index.js";
+export { MysqlBase, loadMysql2 } from "./shared/mysql-base.js";
+export { mysqlDialect } from "./shared/mysql-dialect.js";

package/dist/esm/mysql/clients/mariadb-client/capabilities.js

@@ -0,0 +1,28 @@
+export const MARIADB_CAPABILITIES = {
+    returning: true,
+    lateral: false,
+    distinctOn: false,
+    listenNotify: false,
+    pooling: true,
+    cursors: false,
+    jsonb: false,
+    arrays: false,
+    ranges: false,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: false,
+    storedProcedures: true,
+    triggers: true,
+    sequences: true,
+    copy: false,
+    vacuum: false,
+    identifierQuote: '`',
+    parameterStyle: 'question',
+};

package/dist/esm/mysql/clients/mariadb-client/index.js

@@ -0,0 +1,2 @@
+export { RelqMariaDB } from "./relq-mariadb.js";
+export { MARIADB_CAPABILITIES } from "./capabilities.js";

package/dist/esm/mysql/clients/mariadb-client/relq-mariadb.js

@@ -0,0 +1,10 @@
+import { MysqlBase } from "../shared/mysql-base.js";
+import { MARIADB_CAPABILITIES } from "./capabilities.js";
+export class RelqMariaDB extends MysqlBase {
+    dialect = 'mariadb';
+    capabilities = MARIADB_CAPABILITIES;
+    constructor(schema, config = {}) {
+        const resolvedConfig = { ...config, dialect: 'mariadb' };
+        super(schema, resolvedConfig);
+    }
+}

package/dist/esm/mysql/clients/mysql-client/capabilities.js

@@ -0,0 +1,28 @@
+export const MYSQL_CAPABILITIES = {
+    returning: false,
+    lateral: true,
+    distinctOn: false,
+    listenNotify: false,
+    pooling: true,
+    cursors: false,
+    jsonb: false,
+    arrays: false,
+    ranges: false,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: false,
+    storedProcedures: true,
+    triggers: true,
+    sequences: false,
+    copy: false,
+    vacuum: false,
+    identifierQuote: '`',
+    parameterStyle: 'question',
+};

package/dist/esm/mysql/clients/mysql-client/index.js

@@ -0,0 +1,2 @@
+export { RelqMysql } from "./relq-mysql.js";
+export { MYSQL_CAPABILITIES } from "./capabilities.js";

package/dist/esm/mysql/clients/mysql-client/relq-mysql.js

@@ -0,0 +1,10 @@
+import { MysqlBase } from "../shared/mysql-base.js";
+import { MYSQL_CAPABILITIES } from "./capabilities.js";
+export class RelqMysql extends MysqlBase {
+    dialect = 'mysql';
+    capabilities = MYSQL_CAPABILITIES;
+    constructor(schema, config = {}) {
+        const resolvedConfig = { ...config, dialect: 'mysql' };
+        super(schema, resolvedConfig);
+    }
+}

package/dist/esm/mysql/clients/planetscale-client/capabilities.js

@@ -0,0 +1,28 @@
+export const PLANETSCALE_CAPABILITIES = {
+    returning: false,
+    lateral: false,
+    distinctOn: false,
+    listenNotify: false,
+    pooling: true,
+    cursors: false,
+    jsonb: false,
+    arrays: false,
+    ranges: false,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: false,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: false,
+    savepoints: false,
+    createTableAs: false,
+    materializedViews: false,
+    storedProcedures: false,
+    triggers: false,
+    sequences: false,
+    copy: false,
+    vacuum: false,
+    identifierQuote: '`',
+    parameterStyle: 'question',
+};

package/dist/esm/mysql/clients/planetscale-client/index.js

@@ -0,0 +1,2 @@
+export { RelqPlanetScale } from "./relq-planetscale.js";
+export { PLANETSCALE_CAPABILITIES } from "./capabilities.js";

package/dist/esm/mysql/clients/planetscale-client/relq-planetscale.js

@@ -0,0 +1,28 @@
+import { MysqlBase } from "../shared/mysql-base.js";
+import { PLANETSCALE_CAPABILITIES } from "./capabilities.js";
+export class RelqPlanetScale extends MysqlBase {
+    dialect = 'planetscale';
+    capabilities = PLANETSCALE_CAPABILITIES;
+    psConfig;
+    constructor(schema, config) {
+        const resolvedConfig = { ...config, dialect: 'planetscale' };
+        super(schema, resolvedConfig);
+        this.psConfig = config;
+    }
+    buildConnectionConfig() {
+        return {
+            host: this.psConfig.host,
+            port: 3306,
+            user: this.psConfig.username,
+            password: this.psConfig.password,
+            database: this.psConfig.database || undefined,
+            ssl: {
+                rejectUnauthorized: true,
+            },
+            supportBigNumbers: true,
+            bigNumberStrings: true,
+            timezone: '+00:00',
+            dateStrings: false,
+        };
+    }
+}

package/dist/esm/mysql/clients/shared/index.js

@@ -0,0 +1,7 @@
+export { default as mysqlFormat, mysqlIdent, mysqlLiteral } from "./mysql-format.js";
+export { MysqlDialect, mysqlDialect } from "./mysql-dialect.js";
+export { getMysqlDialectCapabilities } from "./mysql-dialect.js";
+export { isMysqlConnectionError, isMysqlTransientError, isMysqlPoolRecoverableError, parseMysqlError, } from "./mysql-error-parser.js";
+export { mysqlTypeCoercion } from "./mysql-type-coercion.js";
+export { mysqlDeserializeValue, mysqlSerializeValue, mysqlDeserializeRow, mysqlDeserializeRows, mysqlSerializeRow, mysqlExtractSchemaColumns, } from "./mysql-type-coercion.js";
+export { MysqlBase, loadMysql2 } from "./mysql-base.js";

package/dist/esm/mysql/clients/shared/mysql-base.js

@@ -0,0 +1,321 @@
+import { RelqConfigError, RelqConnectionError } from "../../../shared/errors/relq-errors.js";
+import { RelqBase } from "../../../core/relq-base.js";
+import { debugLog } from "../../../core/helpers/methods.js";
+import { mysqlDialect } from "./mysql-dialect.js";
+import { isMysqlConnectionError, isMysqlPoolRecoverableError, parseMysqlError } from "./mysql-error-parser.js";
+import { createMysqlTableAccessor } from "../../shared/mysql-table-accessor.js";
+import { MysqlConnectedRawQueryBuilder } from "../../helpers/MysqlConnectedRawQueryBuilder.js";
+import { NativeCTEBuilder } from "../../../core/cte/native-cte-builder.js";
+import { createMysqlCTEDialect } from "../../../core/cte/cte-types.js";
+import { MysqlConditionCollector } from "../../condition/condition-collector.js";
+import { INTERNAL } from "../../../core/helpers/methods.js";
+import mysqlFormat from "./mysql-format.js";
+let mysql2Module = null;
+export async function loadMysql2() {
+    if (!mysql2Module) {
+        try {
+            const mod = await import("../../utils/addon/mysql/mysql2.js");
+            mysql2Module = (mod.default || mod);
+            return mysql2Module;
+        }
+        catch (error) {
+            throw new RelqConfigError('Failed to load "mysql2" module. Install it with:\n' +
+                '  npm install mysql2\n' +
+                '  # or\n' +
+                '  bun add mysql2', { field: 'mysql2', value: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    return mysql2Module;
+}
+export class MysqlBase extends RelqBase {
+    sqlDialect = mysqlDialect;
+    pool;
+    conn;
+    usePooling;
+    clientConnected = false;
+    mysqlConfig;
+    poolErrorHandler;
+    constructor(schema, config) {
+        super(schema, config);
+        this.mysqlConfig = config;
+        this.usePooling = this.determineMysqlPoolingStrategy();
+    }
+    async _initialize() {
+        const mysql2 = await loadMysql2();
+        const connectionConfig = this.buildConnectionConfig();
+        if (this.usePooling) {
+            this.pool = mysql2.createPool({
+                ...connectionConfig,
+                waitForConnections: true,
+                connectionLimit: 10,
+                queueLimit: 0,
+                enableKeepAlive: true,
+                keepAliveInitialDelay: 10000,
+            });
+            this.setupPoolErrorHandling();
+            debugLog(this.mysqlConfig, 'MySQL pool created', {
+                host: connectionConfig.host,
+                port: connectionConfig.port,
+                database: connectionConfig.database,
+            });
+        }
+        else {
+            this.conn = await mysql2.createConnection(connectionConfig);
+            this.clientConnected = true;
+            this.conn.on('error', (err) => {
+                this.clientConnected = false;
+                this.emitter.emit('error', err);
+            });
+            debugLog(this.mysqlConfig, 'MySQL single connection created');
+        }
+    }
+    async _query(sql, isBuilder = true) {
+        const executeQuery = async () => {
+            if (this.pool) {
+                const [rows, fields] = await this.pool.execute(sql);
+                return this.toDriverResult(rows, fields, sql);
+            }
+            else if (this.conn) {
+                if (!this.clientConnected) {
+                    throw new RelqConnectionError('MySQL connection is closed');
+                }
+                const [rows, fields] = await this.conn.execute(sql);
+                return this.toDriverResult(rows, fields, sql);
+            }
+            else {
+                throw new RelqConfigError('No MySQL connection available');
+            }
+        };
+        try {
+            return await executeQuery();
+        }
+        catch (error) {
+            if (isMysqlConnectionError(error) && !this.usePooling && this.conn) {
+                this.clientConnected = false;
+                try {
+                    await this.reconnectSingleClient();
+                    const [rows, fields] = await this.conn.execute(sql);
+                    return this.toDriverResult(rows, fields, sql);
+                }
+                catch {
+                    throw parseMysqlError(error, sql, isBuilder);
+                }
+            }
+            throw parseMysqlError(error, sql, isBuilder);
+        }
+    }
+    async _acquireClient() {
+        if (this.pool) {
+            const conn = await this.pool.getConnection();
+            return { client: conn, release: () => conn.release() };
+        }
+        else if (this.conn) {
+            return { client: this.conn, release: () => { } };
+        }
+        else {
+            throw new RelqConnectionError('No MySQL connection available');
+        }
+    }
+    async _close() {
+        if (this.pool) {
+            if (this.poolErrorHandler) {
+                this.pool.removeListener('error', this.poolErrorHandler);
+            }
+            this.pool.removeAllListeners();
+            await this.pool.end();
+            this.pool = undefined;
+        }
+        else if (this.conn) {
+            this.conn.removeAllListeners();
+            await this.conn.end();
+            this.conn = undefined;
+            this.clientConnected = false;
+        }
+    }
+    toDriverResult(rows, fields, sql) {
+        const command = this.detectCommand(sql);
+        if (Array.isArray(rows)) {
+            return {
+                rows: rows,
+                rowCount: rows.length,
+                command,
+                fields: (fields || []).map((f) => ({
+                    name: f.name,
+                    dataTypeID: f.columnType,
+                    typeName: f.type,
+                })),
+            };
+        }
+        const header = rows;
+        return {
+            rows: [],
+            rowCount: header.affectedRows ?? null,
+            command,
+            fields: [],
+        };
+    }
+    detectCommand(sql) {
+        const trimmed = sql.trimStart().toUpperCase();
+        if (trimmed.startsWith('SELECT'))
+            return 'SELECT';
+        if (trimmed.startsWith('INSERT'))
+            return 'INSERT';
+        if (trimmed.startsWith('UPDATE'))
+            return 'UPDATE';
+        if (trimmed.startsWith('DELETE'))
+            return 'DELETE';
+        if (trimmed.startsWith('REPLACE'))
+            return 'REPLACE';
+        if (trimmed.startsWith('CREATE'))
+            return 'CREATE';
+        if (trimmed.startsWith('ALTER'))
+            return 'ALTER';
+        if (trimmed.startsWith('DROP'))
+            return 'DROP';
+        if (trimmed.startsWith('EXPLAIN'))
+            return 'EXPLAIN';
+        if (trimmed.startsWith('SHOW'))
+            return 'SHOW';
+        if (trimmed.startsWith('DESCRIBE') || trimmed.startsWith('DESC'))
+            return 'DESCRIBE';
+        if (trimmed.startsWith('SET'))
+            return 'SET';
+        if (trimmed.startsWith('BEGIN') || trimmed.startsWith('START'))
+            return 'BEGIN';
+        if (trimmed.startsWith('COMMIT'))
+            return 'COMMIT';
+        if (trimmed.startsWith('ROLLBACK'))
+            return 'ROLLBACK';
+        return 'UNKNOWN';
+    }
+    buildConnectionConfig() {
+        const config = this.mysqlConfig;
+        return {
+            host: config.host || process.env['MYSQL_HOST'] || 'localhost',
+            port: config.port || Number(process.env['MYSQL_PORT']) || 3306,
+            user: config.user || process.env['MYSQL_USER'] || 'root',
+            password: config.password || process.env['MYSQL_PASSWORD'] || '',
+            database: config.database || process.env['MYSQL_DATABASE'],
+            ssl: config.ssl || undefined,
+            supportBigNumbers: true,
+            bigNumberStrings: true,
+            timezone: '+00:00',
+            dateStrings: false,
+        };
+    }
+    determineMysqlPoolingStrategy() {
+        return true;
+    }
+    setupPoolErrorHandling() {
+        if (!this.pool)
+            return;
+        this.poolErrorHandler = (err) => {
+            this.emitter.emit('error', err);
+            if (isMysqlPoolRecoverableError(err)) {
+                const logLevel = this.mysqlConfig.logLevel ?? 'info';
+                if (logLevel !== 'silent') {
+                    console.warn('[Relq MySQL Pool] Recoverable connection error (pool will auto-recover):', {
+                        code: err.errno || err.code,
+                        message: err.message,
+                        action: 'Connection removed from pool, will be replaced on next query',
+                    });
+                }
+                return;
+            }
+            const logLevel = this.mysqlConfig.logLevel ?? 'info';
+            if (logLevel !== 'silent') {
+                console.error('[Relq MySQL Pool] Pool error:', {
+                    code: err.errno || err.code,
+                    message: err.message,
+                });
+            }
+        };
+        this.pool.on('error', this.poolErrorHandler);
+    }
+    async reconnectSingleClient() {
+        const mysql2 = await loadMysql2();
+        const connectionConfig = this.buildConnectionConfig();
+        if (this.conn) {
+            try {
+                this.conn.removeAllListeners();
+                this.conn.destroy();
+            }
+            catch { }
+        }
+        this.conn = await mysql2.createConnection(connectionConfig);
+        this.clientConnected = true;
+        this.conn.on('error', (err) => {
+            this.clientConnected = false;
+            this.emitter.emit('error', err);
+        });
+        this.emitter.emit('connect', this.conn);
+    }
+    async lastInsertId() {
+        await this.ensureInitialized();
+        const result = await this._query('SELECT LAST_INSERT_ID() AS `id`');
+        const raw = result.rows[0]?.id;
+        return typeof raw === 'string' ? BigInt(raw) : BigInt(raw);
+    }
+    async executeRaw(sql, params) {
+        await this.ensureInitialized();
+        const execute = async () => {
+            if (this.pool) {
+                return await this.pool.execute(sql, params);
+            }
+            else if (this.conn) {
+                return await this.conn.execute(sql, params);
+            }
+            else {
+                throw new RelqConnectionError('No MySQL connection available');
+            }
+        };
+        try {
+            const [rows, fields] = await execute();
+            return this.toDriverResult(rows, fields, sql);
+        }
+        catch (error) {
+            throw parseMysqlError(error, sql);
+        }
+    }
+    get table() {
+        return createMysqlTableAccessor(this, this.schema);
+    }
+    raw(query, ...params) {
+        return new MysqlConnectedRawQueryBuilder(query, params, this);
+    }
+    async transaction(callback, options) {
+        const { executeMysqlTransaction } = await import("../../helpers/MysqlConnectedTransactionBuilder.js");
+        return executeMysqlTransaction(this, callback, options);
+    }
+    cte() {
+        return new NativeCTEBuilder(this, createMysqlCTEDialect(), (relq) => createMysqlTableAccessor(relq, this._getSchema()));
+    }
+    async ctAs(tableName, query, options = {}) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        const temp = options.temporary ? 'TEMPORARY ' : '';
+        const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';
+        const sql = `CREATE ${temp}TABLE ${ifNotExists}${mysqlFormat.ident(tableName)} AS ${queryStr}`;
+        await this[INTERNAL].executeQuery(sql);
+    }
+    async explain(query, options = {}) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        const prefix = options.analyze ? 'EXPLAIN ANALYZE' : 'EXPLAIN';
+        const sql = `${prefix} ${queryStr}`;
+        const { result } = await this._executeQuery(sql);
+        return result.rows;
+    }
+    scalar(scalars) {
+        const { MysqlConnectedScalarSelectBuilder } = require('../../select/scalar-select-builder');
+        const schema = this._getSchema();
+        return new MysqlConnectedScalarSelectBuilder(scalars, schema, {
+            executeSelectOne: this[INTERNAL].executeSelect.bind(this),
+            hasColumnMapping: this._hasColumnMapping.bind(this),
+            transformToDbColumns: this._transformToDbColumns.bind(this)
+        });
+    }
+    where(tableName) {
+        const collector = new MysqlConditionCollector();
+        collector._tableName = tableName;
+        return collector;
+    }
+}

package/dist/esm/mysql/clients/shared/mysql-dialect.js

@@ -0,0 +1,136 @@
+const MYSQL_VARIANT_CAPABILITIES = {
+    mysql: {
+        supportsReturning: false,
+        supportsForeignKeys: true,
+        supportsCtesRecursive: true,
+        supportsWindowFunctions: true,
+        supportsJsonTable: true,
+        supportsExplainAnalyze: true,
+        supportsCheckConstraints: true,
+        supportsGeneratedColumns: true,
+        supportsInvisibleColumns: true,
+        defaultCharset: 'utf8mb4',
+        defaultCollation: 'utf8mb4_0900_ai_ci',
+    },
+    mariadb: {
+        supportsReturning: true,
+        supportsForeignKeys: true,
+        supportsCtesRecursive: true,
+        supportsWindowFunctions: true,
+        supportsJsonTable: false,
+        supportsExplainAnalyze: true,
+        supportsCheckConstraints: true,
+        supportsGeneratedColumns: true,
+        supportsInvisibleColumns: true,
+        defaultCharset: 'utf8mb4',
+        defaultCollation: 'utf8mb4_uca1400_ai_ci',
+    },
+    planetscale: {
+        supportsReturning: false,
+        supportsForeignKeys: false,
+        supportsCtesRecursive: true,
+        supportsWindowFunctions: true,
+        supportsJsonTable: true,
+        supportsExplainAnalyze: true,
+        supportsCheckConstraints: true,
+        supportsGeneratedColumns: true,
+        supportsInvisibleColumns: false,
+        defaultCharset: 'utf8mb4',
+        defaultCollation: 'utf8mb4_0900_ai_ci',
+    },
+};
+export function getMysqlDialectCapabilities(variant) {
+    return MYSQL_VARIANT_CAPABILITIES[variant];
+}
+export class MysqlDialect {
+    name = 'mysql';
+    quoteIdentifier(name) {
+        if (name === '*')
+            return '*';
+        if (name.includes('.')) {
+            return name.split('.').map(p => p === '*' ? '*' : `\`${p.replace(/`/g, '``')}\``).join('.');
+        }
+        return `\`${name.replace(/`/g, '``')}\``;
+    }
+    quoteString(value) {
+        return `'${value.replace(/'/g, "''")}'`;
+    }
+    formatBoolean(value) {
+        return value ? 'TRUE' : 'FALSE';
+    }
+    returning(columns) {
+        return `RETURNING ${columns.map(c => c === '*' ? '*' : this.quoteIdentifier(c)).join(', ')}`;
+    }
+    upsert(_conflictColumns, updateColumns) {
+        const sets = Object.keys(updateColumns)
+            .map(c => `${this.quoteIdentifier(c)} = VALUES(${this.quoteIdentifier(c)})`)
+            .join(', ');
+        return `ON DUPLICATE KEY UPDATE ${sets}`;
+    }
+    distinctOn(_columns) {
+        throw new Error('DISTINCT ON is not supported in MySQL. Use GROUP BY with ANY_VALUE() instead.');
+    }
+    lateralSubquery(_subquery, _alias) {
+        throw new Error('LATERAL JOIN is not used in MySQL family. Use correlated subqueries instead.');
+    }
+    jsonAgg(expression, alias) {
+        return `COALESCE(JSON_ARRAYAGG(${expression}), JSON_ARRAY()) AS ${this.quoteIdentifier(alias)}`;
+    }
+    rowToJson(alias) {
+        return `JSON_OBJECT(${alias}.*)`;
+    }
+    explain(query, options) {
+        const parts = ['EXPLAIN'];
+        if (options.format) {
+            parts.push(`FORMAT = ${options.format.toUpperCase()}`);
+        }
+        if (options.analyze) {
+            parts.push('ANALYZE');
+        }
+        return `${parts.join(' ')} ${query}`;
+    }
+    typeCast(expression, targetType) {
+        return `CAST(${expression} AS ${targetType})`;
+    }
+    currentTimestamp() {
+        return 'NOW()';
+    }
+    randomUuid() {
+        return 'UUID()';
+    }
+    supports(capability) {
+        return MYSQL_BASE_CAPABILITIES[capability] === true;
+    }
+    transformSql(sql) {
+        return sql;
+    }
+}
+export const mysqlDialect = new MysqlDialect();
+const MYSQL_BASE_CAPABILITIES = {
+    returning: false,
+    lateral: false,
+    distinctOn: false,
+    listenNotify: false,
+    pooling: true,
+    cursors: true,
+    jsonb: false,
+    arrays: false,
+    ranges: false,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: false,
+    storedProcedures: true,
+    triggers: true,
+    sequences: false,
+    copy: false,
+    vacuum: false,
+    identifierQuote: '`',
+    parameterStyle: 'question',
+};