@supalive/core 0.1.4 → 0.1.5

package/dist/src/db/mysql.js

@@ -1,708 +0,0 @@
-import mysql from "mysql2/promise";
-import { normalizeIdToBytes, normalizeToBytes, OccConflictError } from "./types_db";
-import { utf8Encode } from "./bytes";
-// mysql2 expects Buffer (not plain Uint8Array) for binary params.
-function toBufferView(bytes) {
-    if (Buffer.isBuffer(bytes))
-        return bytes;
-    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-}
-import { checkLogsAffectReadSet, mapReadSetToRaw } from "../server/overlap-checker";
-import { supaliveStringify } from "../helper";
-/**
- * mysql2 returns `ResultSetHeader` for non-SELECT queries (carrying
- * `affectedRows`) and `RowDataPacket[]` for SELECTs. The previous shim
- * blindly cast to T[] which made `rowCount` zero for UPDATE/DELETE, breaking
- * CAS detection. This helper picks the right shape.
- */
-function normalizeMysqlResult(raw) {
-    if (Array.isArray(raw)) {
-        return { rows: raw, rowCount: raw.length };
-    }
-    if (raw && typeof raw === "object" && "affectedRows" in raw) {
-        return { rows: [], rowCount: Number(raw.affectedRows) || 0 };
-    }
-    return { rows: [], rowCount: 0 };
-}
-export class MySqlDatabase {
-    constructor(logger, config, pool = undefined) {
-        this.logger = logger;
-        const { queryTimeoutMs, ...poolConfig } = config;
-        this.queryTimeoutMs = queryTimeoutMs ?? 0;
-        this.config = poolConfig;
-        if (pool) {
-            this.pool = pool;
-        }
-        else {
-            this.pool = mysql.createPool(poolConfig);
-        }
-    }
-    logger;
-    config;
-    queryTimeoutMs;
-    pool;
-    dbType = "mysql";
-    sqlBuilder = mysqlSql;
-    // Lazy per-table column-type cache. The apply path consults this for
-    // unnest carriers/casts in batched writes; we never re-query pg_attribute
-    // for a table we've already seen unless the cache is explicitly
-    // invalidated (e.g. after a migration). Shared with tx clients via
-    // adoptRegistries so a single startup load services all transactions.
-    columnTypes = new Map();
-    // Compiled-SQL cache keyed by (op, table, sorted column signature).
-    // Mirrors columnTypes — invalidated together when types change.
-    sqlCache = new Map();
-    /**
-     * Fetches actual column types from MySQL for `table` and returns a
-     * map of DB column name → MySQL type string (as produced by `COLUMN_TYPE`,
-     * e.g. `bigint`, `integer`, `varchar(32)`, `text`, `json`).
-     * No caching here — see {@link getColumnTypes} for the cached path.
-     */
-    async loadColumnTypesFromMySql(table) {
-        const result = await this.query(`SELECT COLUMN_NAME AS column_name, COLUMN_TYPE AS mysql_type
-         FROM INFORMATION_SCHEMA.COLUMNS
-         WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
-         ORDER BY ORDINAL_POSITION`, [table]);
-        // MySQL folds unquoted identifiers to lowercase on the server side, so
-        // COLUMN_NAME comes back lowercase. JS-side column keys
-        // (`entry.data`) often arrive in camelCase from the schema layer; we
-        // lookup via lowercase to bridge the two cases without making callers
-        // worry about it.
-        const out = new Map();
-        for (const row of result.rows)
-            out.set(row.column_name.toLowerCase(), row.mysql_type);
-        return out;
-    }
-    /**
-     * Synchronous column-type lookup. The apply path calls this on every
-     * batched write, so it can't await — populate the cache via
-     * {@link bootstrapColumnTypes} at server start. Throws if `table` is
-     * missing (programmer error / bootstrap skipped).
-     */
-    getColumnTypes(table) {
-        const hit = this.columnTypes.get(table);
-        if (!hit) {
-            this.logger.warn({ table }, "MySqlDatabase: no cached column types fallback to non-batched writes");
-            return null;
-        }
-        return hit;
-    }
-    /**
-     * Eagerly load column types into the in-memory cache. With a Redis
-     * client supplied, attempts the cache key first and falls through to
-     * MySQL on miss (writing the result back to Redis). This is the
-     * "one server queries MySQL, the rest read from Redis" pattern for cold
-     * starts in a multi-instance deploy. Without Redis, always queries MySQL.
-     *
-     * Pass `tables` to limit the load to a specific list; otherwise every
-     * user table in the connected database is loaded.
-     *
-     * The Redis cache key should encode whatever invalidates types in your
-     * environment (typically a schema version / deploy version). The
-     * subscriber in supalive-server.ts is expected to publish a reload
-     * signal after migrations and invoke {@link invalidateColumnTypes}.
-     */
-    async bootstrapColumnTypes(opts) {
-        this.invalidateColumnTypes();
-        const { redis, cacheKey, tables } = opts;
-        // Redis hit path: deserialize the full table → column → mysqlType map
-        // and populate in one shot, skipping any INFORMATION_SCHEMA round-trips.
-        if (redis) {
-            const cached = await redis.getCachedTableColumnTypes(cacheKey);
-            if (cached) {
-                for (const [table, cols] of Object.entries(cached)) {
-                    this.columnTypes.set(table, new Map(Object.entries(cols)));
-                }
-                return;
-            }
-        }
-        // Cache miss (or no Redis): query MySQL for the listed tables
-        // (or enumerate all user tables) and populate.
-        const names = tables ?? await this.listUserTables();
-        for (const t of names) {
-            if (this.columnTypes.has(t))
-                continue;
-            const fresh = await this.loadColumnTypesFromMySql(t);
-            this.columnTypes.set(t, fresh);
-        }
-        // Write back to Redis so subsequent server instances skip the MySQL hop.
-        if (redis) {
-            const dump = {};
-            for (const [table, cols] of this.columnTypes) {
-                dump[table] = Object.fromEntries(Object.entries(cols).sort());
-            }
-            await redis.setCachedTableColumnsTypes(cacheKey, dump);
-        }
-    }
-    /**
-       * Invalidate cached types (and dependent SQL) for `table`, or the entire
-       * cache if `table` is omitted. The Redis-pubsub reload signal in
-       * supalive-server.ts is expected to call this on schema changes.
-       */
-    invalidateColumnTypes(table) {
-        if (table) {
-            this.columnTypes.delete(table);
-            for (const k of [...this.sqlCache.keys()]) {
-                if (k.includes(`:${table}:`) || k === `d:${table}`)
-                    this.sqlCache.delete(k);
-            }
-        }
-        else {
-            this.columnTypes.clear();
-            this.sqlCache.clear();
-        }
-    }
-    /** Replace this instance's caches with shared references from a parent.
-     *  Used by getTransactionClient so types loaded once at startup are
-     *  visible inside transactions. */
-    adoptCaches(columnTypes, sqlCache) {
-        this.columnTypes = columnTypes;
-        this.sqlCache = sqlCache;
-    }
-    /** Enumerate the user-defined tables in the connected database for mysql — used
-     * by bootstrapColumnTypes() when no explicit list is provided. */
-    async listUserTables() {
-        const result = await this.query(`SELECT table_name FROM information_schema.tables
-       WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'
-         AND table_name NOT IN ('commit_logs', 'metadata', 'sequence')`);
-        return result.rows.map(r => r.table_name);
-    }
-    migrationSql = [
-        // Commit logs table (per-entry inserts, note 8)
-        `CREATE TABLE IF NOT EXISTS commit_logs (
-      id BINARY(16) NOT NULL,
-      ts BIGINT NOT NULL,
-      table_id BINARY(16) NOT NULL,
-      data LONGBLOB NOT NULL,
-      PRIMARY KEY (ts, table_id, id),
-      INDEX commit_logs_by_table_and_id (table_id, id, ts)
-    ) ENGINE=InnoDB ROW_FORMAT=DYNAMIC`,
-        // `CREATE INDEX IF NOT EXISTS commit_logs_by_table_ts_and_id ON commit_logs (table_id, ts, id)`,
-        // Timestamp sequence table for MySQL
-        `CREATE TABLE IF NOT EXISTS sequence (id INT NOT NULL)`,
-        `INSERT IGNORE INTO sequence VALUES (0)`,
-        // Metadata table
-        `CREATE TABLE IF NOT EXISTS metadata (
-      meta_key VARCHAR(255) PRIMARY KEY,
-      meta_value BIGINT NOT NULL
-    ) ENGINE=InnoDB;`,
-        `INSERT IGNORE INTO metadata (meta_key, meta_value) VALUES ('latest_committed_ts', 0);`
-    ];
-    async query(sql, params = []) {
-        const client = await this.pool.getConnection();
-        try {
-            const [rows] = this.queryTimeoutMs > 0
-                ? await client.query({ sql, values: params, timeout: this.queryTimeoutMs })
-                : await client.query(sql, params);
-            return normalizeMysqlResult(rows);
-        }
-        catch (err) {
-            throw translateMysqlError(err);
-        }
-        finally {
-            client.release();
-        }
-    }
-    async getClient() {
-        const client = await this.pool.getConnection();
-        return client;
-    }
-    async getTransactionClient() {
-        const client = await this.pool.getConnection();
-        const tx = new MySqlTxDatabase(this.logger, { ...this.config, queryTimeoutMs: this.queryTimeoutMs }, this.pool, client);
-        tx.adoptCaches(this.columnTypes, this.sqlCache);
-        return tx;
-    }
-    async getLatestSnapshotTimestamp() {
-        const result = await this.query("SELECT meta_value FROM metadata WHERE meta_key = 'latest_committed_ts'");
-        return BigInt(result.rows[0]?.meta_value ?? 0) || -1n;
-    }
-    async updateLatestSnapshotTimestamp(commitTs) {
-        await this.query(`UPDATE metadata SET meta_value = ? WHERE meta_key = 'latest_committed_ts' AND meta_value < ?`, [commitTs, commitTs]);
-    }
-    async getNextTimestamp() {
-        const result = await this.query("UPDATE sequence SET id = LAST_INSERT_ID(id + 1); SELECT LAST_INSERT_ID() AS id");
-        return BigInt(result.rows[0]?.id ?? 0) || -1n;
-    }
-    // Runs on the pool, not the tx client — intentionally. This keeps the
-    // transaction window short, but it means `prevData` is not snapshot-
-    // consistent with the eventual commitTs (a peer may have moved the row
-    // between beginTs and this SELECT). That's safe because:
-    //   1. The per-row CAS in pgApplyWrites is the real snapshot fence. If a
-    //      peer committed in our staleness window, the CAS sees a moved
-    //      commit_ts and throws OccConflictError → retry.
-    //   2. The only window where CAS passes with "stale" prevData is when
-    //      the current row at our SELECT moment matches `expectedCommitTs`;
-    //      by construction nobody committed between our captured ts and now,
-    //      so prevData IS consistent with the ts we're CAS-ing against.
-    //   3. The downstream consumer (overlap-checker.checkRowWriteAffectsRange)
-    //      is conservative on missing/odd prevData — "unknown" verdicts still
-    //      invalidate, so the worst case here is a spurious invalidation,
-    //      never a missed one.
-    // Locked in by mysql.attach-prev-data.test.ts.
-    async attachPrevDataToWriteSet(writeSet, readSet) {
-        const readTsByKey = new Map();
-        for (let i = readSet.length - 1; i >= 0; i--) {
-            const r = readSet[i];
-            if (r.kind !== "point" || r.expectedCommitTs === undefined)
-                continue;
-            const key = `${r.table} ${r.id}`;
-            if (!readTsByKey.has(key))
-                readTsByKey.set(key, r.expectedCommitTs);
-        }
-        const byTable = new Map();
-        for (const entry of writeSet) {
-            if (entry.op !== "update" && entry.op !== "delete")
-                continue;
-            const bucket = byTable.get(entry.table);
-            if (bucket)
-                bucket.push(entry);
-            else
-                byTable.set(entry.table, [entry]);
-        }
-        if (byTable.size === 0)
-            return;
-        for (const [table, entries] of byTable) {
-            const ids = entries.map((e) => e.id);
-            const placeholders = ids.map(() => "?").join(", ");
-            // No FOR UPDATE — the per-row CAS on the subsequent UPDATE/DELETE is
-            // the fence. If a peer mutated the row since our read, the CAS will
-            // see a stale expected commit_ts and throw OCC.
-            const sql = `SELECT * FROM ${table} WHERE id IN (${placeholders})`;
-            const result = await this.query(sql, ids);
-            const byId = new Map();
-            for (const row of result.rows) {
-                byId.set(String(row.id), row);
-            }
-            for (const entry of entries) {
-                const row = byId.get(String(entry.id));
-                const key = `${entry.table} ${entry.id}`;
-                const priorReadTs = readTsByKey.get(key);
-                if (row) {
-                    entry.prevData = row;
-                    // Prefer the read-time ts so read-then-update patterns get
-                    // beginTs-level isolation; fall back to current row ts for
-                    // blind writes (no prior read).
-                    entry.expectedCommitTs = priorReadTs !== undefined
-                        ? priorReadTs
-                        : BigInt(row.commit_ts);
-                }
-                else if (priorReadTs !== undefined) {
-                    // Row gone now, but we had read it earlier: carry the read ts —
-                    // the CAS will then mismatch (row deleted) and throw OCC.
-                    entry.expectedCommitTs = priorReadTs;
-                }
-                // else: neither a prior read nor a current row → leave undefined
-                // so CAS misses and surfaces OCC.
-            }
-        }
-    }
-    // Prepare BEFORE the conflict scan: each write is a CAS against the row's
-    // commit_ts, so any concurrent peer that touched the row produces a
-    // 0-row-affected UPDATE/DELETE → OccConflictError. Inserts surface as
-    // PK violations, also translated to OCC.
-    async prepareCommitWrites(readSet, writeSet, commitTs) {
-        const result = [];
-        await this.mysqlPrepareBatchWrites(result, writeSet, commitTs);
-        await this.mysqlPrepareCommitLogs(result, writeSet, commitTs);
-        const hasRangeRead = readSet.some(r => r.kind === "range");
-        if (!hasRangeRead) {
-            const validateReads = this.mysqlPrepareValidatePointReadsByCommitTs(readSet, writeSet);
-            return { commits: result, validateReadPoints: validateReads, hasRangeRead: false };
-        }
-        // has atleast one range read so use scan, prepare data
-        const tableIds = [...new Set(readSet.map(r => r.tableId))];
-        const rawReadSet = mapReadSetToRaw(readSet);
-        return { commits: result, hasRangeRead: true, tableIds: tableIds, rawReadSet: rawReadSet };
-    }
-    async mysqlPrepareBatchWrites(result, writeSet, commitTs) {
-        let i = 0;
-        let counter = 0;
-        while (i < writeSet.length) {
-            counter++;
-            const { table, op } = writeSet[i];
-            let j = i + 1;
-            while (j < writeSet.length && writeSet[j].table === table && writeSet[j].op === op)
-                j++;
-            const batch = writeSet.slice(i, j);
-            if (op === "insert")
-                await this.mysqlPrepareInsertBatch(result, table, batch, commitTs);
-            else if (op === "update")
-                await this.mysqlPrepareUpdateSingle(result, table, batch, commitTs);
-            else
-                await this.mysqlPrepareDeleteBatch(result, table, batch);
-            i = j;
-            if (counter % 50 == 0) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-        }
-    }
-    async mysqlPrepareInsertBatch(result, table, entries, commitTs) {
-        if (entries.length === 0)
-            return;
-        const groups = new Map();
-        for (const entry of entries) {
-            const cols = [...Object.keys(entry.data ?? {}), 'commit_ts'].sort();
-            const key = cols.join("|");
-            let g = groups.get(key);
-            if (!g) {
-                g = { cols, rows: [] };
-                groups.set(key, g);
-            }
-            g.rows.push(entry);
-        }
-        let counter = 0;
-        for (const { cols, rows } of groups.values()) {
-            counter++;
-            const values = [];
-            const tuples = [];
-            for (const entry of rows) {
-                const data = { ...(entry.data ?? {}), commit_ts: commitTs };
-                tuples.push(`(${cols.map(() => "?").join(", ")})`);
-                for (const col of cols) {
-                    values.push(data[col]);
-                }
-            }
-            if (counter % 50 == 0) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-            result.push({
-                sql: `INSERT INTO ${table} (${cols.join(", ")}) VALUES ${tuples.join(", ")}`,
-                params: values,
-                operation: "insertBatch",
-                table: table,
-            });
-        }
-    }
-    async mysqlPrepareUpdateSingle(result, table, entries, commitTs) {
-        if (entries.length === 0)
-            return;
-        let counter = 0;
-        for (const entry of entries) {
-            counter++;
-            const data = { ...(entry.data ?? {}), commit_ts: commitTs };
-            const columns = Object.keys(data);
-            const sets = columns.map((c) => `${c} = ?`);
-            const values = Object.values(data);
-            const expected = entry.expectedCommitTs ?? -1n;
-            if (counter % 50 == 0) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-            result.push({
-                sql: `UPDATE ${table} SET ${sets.join(", ")} WHERE id = ? AND commit_ts = ?`,
-                params: [...values, entry.id, expected],
-                operation: 'updateSingle',
-                table: table,
-                entryId: entry.id,
-                expectedTs: expected,
-            });
-        }
-    }
-    async mysqlPrepareDeleteBatch(result, table, entries) {
-        if (entries.length === 0)
-            return;
-        let counter = 0;
-        for (const entry of entries) {
-            counter++;
-            const expected = entry.expectedCommitTs ?? -1n;
-            if (counter % 50 == 0) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-            result.push({
-                sql: `DELETE FROM ${table} WHERE id = ? AND commit_ts = ?`,
-                params: [entry.id, expected],
-                table: table,
-                operation: 'deleteSingle',
-                entryId: entry.id,
-                expectedTs: expected,
-            });
-        }
-    }
-    async mysqlPrepareCommitLogs(result, writeEntries, commitTs) {
-        if (writeEntries.length === 0)
-            return;
-        const values = [];
-        const tuples = [];
-        let counter = 0;
-        for (const entry of writeEntries) {
-            counter++;
-            tuples.push(`(?, ?, ?, ?)`);
-            values.push(toBufferView(normalizeIdToBytes(entry.id)), commitTs, toBufferView(entry.tableId), toBufferView(utf8Encode(supaliveStringify(entry))));
-            if (counter % 50 == 0) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-        }
-        result.push({
-            sql: `INSERT INTO commit_logs (id, ts, table_id, data) VALUES ${tuples.join(", ")}`,
-            params: values,
-            table: 'commit_logs',
-            operation: 'commit_logs',
-        });
-    }
-    /**
-     * Point-only OCC check. For each genuine point read, compare the row's
-     * current commit_ts against the value captured at read time. A `null`
-     * expectedCommitTs means "row didn't exist when we read"; any row found
-     * now is a conflict. Reads whose row is being written in this same txn
-     * are skipped — the CAS UPDATE/DELETE already validated those.
-     */
-    mysqlPrepareValidatePointReadsByCommitTs(readSet, writeSet) {
-        const result = [];
-        // Skip reads whose row is being mutated in this same tx — CAS already
-        // fenced them. We dedupe per (table, id) so duplicate reads of the same
-        // row don't cause extra fetches.
-        const writeKeys = new Set();
-        for (const w of writeSet)
-            writeKeys.add(`${w.table} ${w.id}`);
-        const byTable = new Map();
-        const seen = new Set();
-        for (const entry of readSet) {
-            if (entry.kind !== "point")
-                continue;
-            const key = `${entry.table} ${entry.id}`;
-            if (writeKeys.has(key) || seen.has(key))
-                continue;
-            seen.add(key);
-            // expectedCommitTs === undefined → no commit_ts captured at read time
-            // (synthetic or pre-migration). Skip — we cannot CAS-validate it. This
-            // path should only fire when callers construct PointReads externally.
-            if (entry.expectedCommitTs === undefined)
-                continue;
-            const bucket = byTable.get(entry.table);
-            if (bucket)
-                bucket.push({ entry, key });
-            else
-                byTable.set(entry.table, [{ entry, key }]);
-        }
-        for (const [table, pendings] of byTable) {
-            const ids = pendings.map((p) => p.entry.id);
-            const placeholders = ids.map(() => "?").join(", ");
-            result.push({
-                sql: `SELECT id, commit_ts FROM ${table} WHERE id IN (${placeholders})`,
-                params: ids,
-                table: table,
-                operation: 'pointReadValidation',
-                pendingsEntry: pendings,
-            });
-        }
-        return result;
-    }
-    async commitWrites(beginTs, queries, commitTs) {
-        await this.mysqlApplyWrites(queries.commits);
-        // Fast path: when the readSet has no range reads, we don't need a
-        // commit-log scan at all — point reads validate via per-row commit_ts,
-        // and writes already self-validated via CAS above. This is the dominant
-        // shape (most mutations target known ids) and eliminates the heaviest
-        // OCC cost in the previous design.
-        if (!queries.hasRangeRead) {
-            if ((queries.validateReadPoints?.length ?? 0) > 0) {
-                await this.validatePointReadsByCommitTs(queries.validateReadPoints ?? []);
-            }
-            return { success: true };
-        }
-        // Slow path: at least one range read present. Fall back to the
-        // commit-log scan so phantom inserts and predicate transitions-in are
-        // still caught. Point reads in the same set are covered by the same
-        // scan, so no separate validation is needed.
-        const logs = await this.getCommitLogsSinceTs(beginTs, commitTs, queries.tableIds ?? []);
-        const hasConflict = checkLogsAffectReadSet(logs, queries.rawReadSet ?? []);
-        if (hasConflict) {
-            throw new OccConflictError(`Conflict detected: overlapping commit logs since ${beginTs}`, { logs });
-        }
-        return { success: true };
-    }
-    // Walks the writeSet in order and coalesces consecutive entries with the
-    // same (table, op) into one batched statement. Order is preserved across
-    // batch boundaries so replace-patterns (delete-then-insert of the same
-    // id) behave identically to the per-row code path. Single-row batches
-    // take a direct INSERT/UPDATE/DELETE fast-path to avoid the unnest+join
-    // overhead, which matters under high contention.
-    async mysqlApplyWrites(result) {
-        for (const q of result) {
-            switch (q.operation) {
-                case 'insertBatch': {
-                    try {
-                        await this.query(q.sql, q.params);
-                    }
-                    catch (err) {
-                        if (err && typeof err === "object" &&
-                            (err.errno === 1062 ||
-                                err.code === "ER_DUP_ENTRY")) {
-                            const msg = err.message ?? "";
-                            const idMatch = msg.match(/key '[^']+'.*?\(.*?\)=\(?([^,\)]+)/);
-                            const failedId = idMatch?.[1];
-                            throw new OccConflictError(failedId !== undefined
-                                ? `Conflict: insert into ${q.table}/${failedId} hit duplicate key`
-                                : `Conflict: batch insert into ${q.table} hit duplicate key`, err);
-                        }
-                        throw err;
-                    }
-                    break;
-                }
-                case 'updateSingle': {
-                    const result = await this.query(q.sql, q.params);
-                    if ((result.rowCount ?? 0) === 0) {
-                        throw new OccConflictError(`Conflict: CAS update of ${q.table}/${q.entryId} (expected commit_ts=${q.expectedTs}) matched no rows`, { table: q.table, id: q.entryId, expected: q.expectedTs });
-                    }
-                    break;
-                }
-                case 'deleteBatch': {
-                    const result = await this.query(q.sql, q.params);
-                    if ((result.rowCount ?? 0) === 0) {
-                        throw new OccConflictError(`Conflict: CAS delete of ${q.table}/${q.entryId} (expected commit_ts=${q.expectedTs}) matched no rows`, { table: q.table, id: q.entryId, expected: q.expectedTs });
-                    }
-                    break;
-                }
-                case 'commit_logs': {
-                    await this.query(q.sql, q.params);
-                    break;
-                }
-                default:
-                    throw new Error("Unhandled MySQL Operation: " + q.operation);
-            }
-        }
-    }
-    async validatePointReadsByCommitTs(queries) {
-        for (const q of queries) {
-            const result = await this.query(q.sql, q.params);
-            const currentById = new Map();
-            for (const row of result.rows) {
-                currentById.set(String(row.id), BigInt(row.commit_ts));
-            }
-            for (const { entry } of q.pendingsEntry ?? []) {
-                const current = currentById.get(String(entry.id));
-                const expected = entry.expectedCommitTs;
-                if (expected === null) {
-                    // We read "no row"; conflict if a row now exists.
-                    if (current !== undefined) {
-                        throw new OccConflictError(`Conflict: row ${entry.table}/${entry.id} was inserted concurrently`, { table: entry.table, id: entry.id });
-                    }
-                }
-                else {
-                    if (current === undefined) {
-                        throw new OccConflictError(`Conflict: row ${entry.table}/${entry.id} was deleted concurrently`, { table: entry.table, id: entry.id, expected });
-                    }
-                    if (current !== expected) {
-                        throw new OccConflictError(`Conflict: row ${entry.table}/${entry.id} changed from ts=${expected} to ts=${current}`, { table: entry.table, id: entry.id, expected, current });
-                    }
-                }
-            }
-        }
-    }
-    async pruneCommitLogsBefore(ts) {
-        const result = await this.query(`DELETE FROM commit_logs WHERE ts < ?`, [ts]);
-        return BigInt(result.rowCount ?? 0);
-    }
-    async getCommitLogsBetweenTs(beginTs, endTs, tableIds) {
-        if (tableIds.length === 0)
-            return [];
-        const placeholders = tableIds.map(() => '?').join(", ");
-        const sql = `SELECT id, ts, table_id, data FROM commit_logs WHERE ts >= ? AND ts < ? AND table_id IN (${placeholders})`;
-        const result = await this.query(sql, [beginTs, endTs, ...tableIds.map(toBufferView)]);
-        return result.rows.map((row) => ({
-            id: normalizeToBytes(row.id),
-            ts: BigInt(row.ts),
-            tableId: normalizeToBytes(row.table_id),
-            data: normalizeToBytes(row.data),
-        }));
-    }
-    async getCommitLogsSinceTs(sinceTs, excludeTs, tableIds) {
-        if (tableIds.length === 0)
-            return [];
-        const placeholders = tableIds.map(() => '?').join(", ");
-        const sql = `SELECT id, ts, table_id, data FROM commit_logs WHERE ts >= ? AND ts <> ? AND table_id IN (${placeholders})`;
-        const result = await this.query(sql, [sinceTs, excludeTs, ...tableIds.map(toBufferView)]);
-        return result.rows.map((row) => ({
-            id: normalizeToBytes(row.id),
-            ts: BigInt(row.ts),
-            tableId: normalizeToBytes(row.table_id),
-            data: normalizeToBytes(row.data),
-        }));
-    }
-    async close() {
-        await this.pool.end();
-    }
-}
-export class MySqlTxDatabase extends MySqlDatabase {
-    constructor(logger, config, pool, client) {
-        super(logger, config, pool);
-        this.client = client;
-    }
-    client;
-    async query(sql, params = []) {
-        try {
-            const [rows] = this.queryTimeoutMs > 0
-                ? await this.client.query({ sql, values: params, timeout: this.queryTimeoutMs })
-                : await this.client.query(sql, params);
-            return normalizeMysqlResult(rows);
-        }
-        catch (err) {
-            throw translateMysqlError(err);
-        }
-    }
-    async begin() {
-        await this.client.beginTransaction();
-    }
-    async commit() {
-        await this.client.commit();
-    }
-    async rollback() {
-        await this.client.rollback();
-    }
-    release() {
-        this.client.release();
-    }
-}
-/**
- * MySQL InnoDB deadlock (errno 1213 / SQLSTATE 40001) is transient and
- * semantically equivalent to an OCC conflict from the mutation runner's
- * perspective: re-execute the handler with a fresh snapshot. Wrapping
- * here lets realtime_db.ts stay driver-agnostic — its retry loop already
- * handles OccConflictError.
- */
-function translateMysqlError(err) {
-    if (err && typeof err === "object" &&
-        (err.errno === 1213 ||
-            err.code === "ER_LOCK_DEADLOCK")) {
-        return new OccConflictError("deadlock detected", err);
-    }
-    return err;
-}
-const mysqlSql = {
-    placeholder: (i) => `?`,
-    like: (col, i) => `${col} LIKE ?`,
-    ilike: (col, i) => `${col} LIKE ?`, // MySQL doesn't have ILIKE
-    icontains: (col, i) => `${col} LIKE ?`,
-    // CAST(? AS JSON) lets the driver bind the param as a regular string
-    // (JSON-serialized client-side) and MySQL re-parses it into a JSON value
-    // for containment comparison. When a sub-path is set, JSON_CONTAINS takes
-    // the path as its third argument.
-    jsonContains: (col, _i, opts) => opts?.pathIndex !== undefined
-        ? `JSON_CONTAINS(${col}, CAST(? AS JSON), ?)`
-        : `JSON_CONTAINS(${col}, CAST(? AS JSON))`,
-    jsonContainedBy: (col, _i, opts) => opts?.pathIndex !== undefined
-        // For "is the column contained in the candidate at this sub-path of the
-        // column" we still need to extract the sub-path from the column side.
-        // JSON_CONTAINS's path arg is on the TARGET position, so we flip and use
-        // JSON_EXTRACT for the column side instead.
-        ? `JSON_CONTAINS(CAST(? AS JSON), JSON_EXTRACT(${col}, ?))`
-        : `JSON_CONTAINS(CAST(? AS JSON), ${col})`,
-    jsonHasKey: (col, _i, opts) => {
-        if (opts?.pathCount && opts.pathCount > 0) {
-            const mode = opts.mode === "all" ? "'all'" : "'one'";
-            const places = new Array(opts.pathCount).fill("?").join(", ");
-            return `JSON_CONTAINS_PATH(${col}, ${mode}, ${places})`;
-        }
-        return opts?.raw
-            // Param is already a JSON path expression like `$.foo.bar` or `$."a"."b"`.
-            ? `JSON_CONTAINS_PATH(${col}, 'one', ?)`
-            // Param is a literal top-level key. Wrap it in `$."<key>"` server-side
-            // and escape any embedded double-quotes so dotted keys behave as keys
-            // and not nested paths.
-            : `JSON_CONTAINS_PATH(${col}, 'one', CONCAT('$."', REPLACE(?, '"', '\\\\"'), '"'))`;
-    },
-    jsonArrayContains: (col, _i, opts) => opts?.pathIndex !== undefined
-        ? `JSON_CONTAINS(${col}, JSON_ARRAY(CAST(? AS JSON)), ?)`
-        : `JSON_CONTAINS(${col}, JSON_ARRAY(CAST(? AS JSON)))`,
-};
-//# sourceMappingURL=mysql.js.map