@syncular/server 0.37.0 → 0.39.0

package/src/pull.ts

@@ -484,8 +484,8 @@ async function* bootstrapSegments(
 /**
  * The storage reads a section needs before its first frame. A pull starts
  * them for every subscription before awaiting any, so a storage that batches
- * concurrent page reads (PostgreSQL, D1) answers all subscriptions of one
- * table with one statement, and the horizon re-check runs once per pull.
+ * concurrent page reads (PostgreSQL, D1) answers the first pages of every
+ * subscription in one statement, and the horizon re-check runs once per pull.
  */
 export interface PreparedSection {
   /** §4.5 window read for an incremental cursor; empty when none was read. */
@@ -499,7 +499,11 @@ export interface PreparedSection {
   readonly firstPage: StoredRow[] | undefined;
   /** §4.7 pin of a fresh bootstrap; absent ⇒ `maxCommitSeq`. */
   readonly pin: number | undefined;
-  /** §5.3 stored image for a sqlite-lane bootstrap's reuse key, if any. */
+  /**
+   * §5.3 stored image for a sqlite-lane bootstrap's reuse key. Read only when
+   * the eligibility probe shows a snapshot larger than one rows page, since a
+   * smaller table can never match a stored image.
+   */
   readonly image: SegmentRecord | undefined;
 }
 
@@ -574,21 +578,30 @@ export async function prepareSections(
               const pin = Math.min(maxSeq, Math.max(latest, horizonSeq));
               return { asOf: pin, pin };
             });
-    const lane = pinned.then(async ({ asOf, pin }) => ({
-      pin,
-      image: await ctx.segments.find(
-        {
-          partition: ctx.partition,
-          logEpoch,
-          table: plan.table.name,
-          schemaVersion: schema.version,
-          mediaType: 'sqlite',
-          scopeDigest: await scopeDigest(plan.effective),
-          asOfCommitSeq: asOf,
-        },
-        clockOf(ctx)(),
-      ),
-    }));
+    const lane = pinned.then(async ({ asOf, pin }) => {
+      // §5.3 eligibility: a stored image only matches a snapshot larger than
+      // one rows page, so the probe decides before the reuse lookup; a remote
+      // `find` on a small table would be a wasted round trip.
+      const probe = await firstPage;
+      if (probe.length <= limits.limitSnapshotRows) {
+        return { pin, image: undefined };
+      }
+      return {
+        pin,
+        image: await ctx.segments.find(
+          {
+            partition: ctx.partition,
+            logEpoch,
+            table: plan.table.name,
+            schemaVersion: schema.version,
+            mediaType: 'sqlite',
+            scopeDigest: await scopeDigest(plan.effective),
+            asOfCommitSeq: asOf,
+          },
+          clockOf(ctx)(),
+        ),
+      };
+    });
     return { firstPage, lane };
   });
   const settled = await Promise.all(

package/src/relational-rows.ts

@@ -53,7 +53,12 @@ import {
   type RowColumn,
   type RowValue,
 } from '@syncular/core';
-import type { CompiledSchema, CompiledTable, IndexSchema } from './schema';
+import type {
+  CompiledSchema,
+  CompiledTable,
+  IndexSchema,
+  ServerIndexSchema,
+} from './schema';
 import type { StoredRow } from './storage';
 import { StorageQueryError } from './storage-errors';
 
@@ -356,8 +361,8 @@ export function addColumnDdl(
 
 /**
  * Ownership marker for server-created projection indexes. A version bump
- * rebuilds declared indexes by dropping every index Syncular owns and
- * re-creating the declared set; this prefix is what marks an index as
+ * drops every index Syncular owns whose definition changed or was removed
+ * and creates the missing ones; this prefix is what marks an index as
  * Syncular-owned, so operator-added tuning indexes survive bumps. Portable
  * identifier validation reserves the `sync_` prefix for the server storage
  * namespace, which keeps user and operator index names out of it.
@@ -388,22 +393,113 @@ export function physicalIndexName(declaredName: string): string {
 }
 
 /**
- * CREATE INDEX IF NOT EXISTS for the table's user-declared indexes. These use
- * the declared columns with a leading server partition column. Cross-table
+ * Physical name of one server-only index. The name carries a fingerprint of
+ * the definition, so a changed definition is a different index and the bump
+ * diff needs no catalog comparison of predicates.
+ */
+export function physicalServerIndexName(index: ServerIndexSchema): string {
+  const fingerprint = fnv1a64Hex(
+    JSON.stringify([index.columns, index.where ?? null]),
+  ).slice(0, 8);
+  const readable = `${SYNC_INDEX_PREFIX}${index.name}_${fingerprint}`;
+  if (new TextEncoder().encode(readable).length <= 63) return readable;
+  return `${SYNC_INDEX_PREFIX}${fnv1a64Hex(index.name)}_${fingerprint}`;
+}
+
+/**
+ * Canonical shape of one physical index, as read from the catalog and as
+ * declared: kind, then the key columns in order (`null` for an expression).
+ * Two indexes with one signature are interchangeable.
+ */
+export function indexSignature(
+  columns: readonly (string | null)[],
+  unique: boolean,
+  partial: boolean,
+): string {
+  return `${unique ? 'unique' : 'index'}${partial ? ' partial' : ''}(${columns.map((column) => column ?? '?').join(',')})`;
+}
+
+/**
+ * One statement that lists a table's free-standing SQLite indexes with their
+ * key columns in order (bind the table name). `origin='c'` excludes
+ * constraint-owned indexes, which only their constraint can remove. Feed the
+ * rows to {@link sqliteIndexSignatures}.
+ */
+export const SQLITE_TABLE_INDEXES_SQL = `SELECT il.name AS name, il."unique" AS is_unique, il.partial AS is_partial, ii.name AS column_name
+  FROM pragma_index_list(?) AS il
+  JOIN pragma_index_info(il.name) AS ii
+ WHERE il.origin='c'
+ ORDER BY il.name, ii.seqno`;
+
+export interface SqliteTableIndexRow {
+  readonly name: string;
+  readonly is_unique: number;
+  readonly is_partial: number;
+  readonly column_name: string | null;
+}
+
+/** Index name to {@link indexSignature} for the rows of one table. */
+export function sqliteIndexSignatures(
+  rows: readonly SqliteTableIndexRow[],
+): Record<string, string> {
+  const shapes = new Map<
+    string,
+    { unique: boolean; partial: boolean; columns: (string | null)[] }
+  >();
+  for (const row of rows) {
+    const shape = shapes.get(row.name) ?? {
+      unique: row.is_unique === 1,
+      partial: row.is_partial === 1,
+      columns: [],
+    };
+    shape.columns.push(row.column_name);
+    shapes.set(row.name, shape);
+  }
+  return Object.fromEntries(
+    [...shapes].map(([name, shape]) => [
+      name,
+      indexSignature(shape.columns, shape.unique, shape.partial),
+    ]),
+  );
+}
+
+interface DesiredIndex {
+  readonly name: string;
+  /** Absent when the physical name already fingerprints the definition. */
+  readonly signature: string | undefined;
+  readonly ddl: string;
+}
+
+/**
+ * The table's declared and server-only indexes. Declared indexes use the
+ * declared columns with a leading server partition column. Cross-table
  * index-name uniqueness is the user's schema concern, as it is client-side.
  * Server-side the physical name carries the {@link SYNC_INDEX_PREFIX}
  * ownership marker.
  */
-export function createIndexDdl(table: CompiledTable): string[] {
+function desiredIndexes(table: CompiledTable): DesiredIndex[] {
   // User indexes name app columns — nothing to index without the projection.
   if (!table.materialize) return [];
-  return table.indexes.map((index) => {
-    const unique = index.unique ? 'UNIQUE ' : '';
-    const columns = [SYNC_PARTITION_COLUMN, ...index.columns]
-      .map((column) => quoteIdent(column))
-      .join(', ');
-    return `CREATE ${unique}INDEX IF NOT EXISTS ${quoteIdent(physicalIndexName(index.name))} ON ${quoteIdent(table.name)} (${columns})`;
-  });
+  return [
+    ...table.indexes.map((index) => {
+      const unique = index.unique === true;
+      const columns = [SYNC_PARTITION_COLUMN, ...index.columns];
+      const name = physicalIndexName(index.name);
+      return {
+        name,
+        signature: indexSignature(columns, unique, false),
+        ddl: `CREATE ${unique ? 'UNIQUE ' : ''}INDEX IF NOT EXISTS ${quoteIdent(name)} ON ${quoteIdent(table.name)} (${columns.map((column) => quoteIdent(column)).join(', ')})`,
+      };
+    }),
+    ...table.serverIndexes.map((index) => {
+      const name = physicalServerIndexName(index);
+      return {
+        name,
+        signature: undefined,
+        ddl: `CREATE INDEX IF NOT EXISTS ${quoteIdent(name)} ON ${quoteIdent(table.name)} (${index.columns.map((column) => quoteIdent(column)).join(', ')})${index.where === undefined ? '' : ` WHERE ${index.where}`}`,
+      };
+    }),
+  ];
 }
 
 /** Idempotent removal of one Syncular-owned relational projection index. */
@@ -470,26 +566,31 @@ export function upsertValues(
   ];
 }
 
-function placeholderList(count: number, dialect: RelationalDialect): string {
-  if (dialect === 'sqlite') return new Array(count).fill('?').join(',');
-  const out: string[] = [];
-  for (let i = 1; i <= count; i++) out.push(`$${i}`);
-  return out.join(',');
-}
-
-/** Upsert statement text (bind with `upsertValues`). */
+/**
+ * Upsert statement text (bind with `upsertValues`). PostgreSQL takes `rows`
+ * rows in one statement, bound as consecutive `upsertValues` lists; their
+ * row ids must be distinct.
+ */
 export function upsertSql(
   table: CompiledTable,
   dialect: RelationalDialect,
+  rows = 1,
 ): string {
   const names = tableColumnNames(table);
   const quoted = names.map((name) => quoteIdent(name)).join(', ');
-  const values = placeholderList(names.length, dialect);
+  const values =
+    dialect === 'sqlite'
+      ? `(${new Array(names.length).fill('?').join(',')})`
+      : Array.from(
+          { length: rows },
+          (_, row) =>
+            `(${names.map((_, column) => `$${row * names.length + column + 1}`).join(',')})`,
+        ).join(',');
   const updates = names
     .slice(2) // partition + row id are the conflict key
     .map((name) => `${quoteIdent(name)}=excluded.${quoteIdent(name)}`)
     .join(', ');
-  return `INSERT INTO ${quoteIdent(table.name)} (${quoted}) VALUES (${values})
+  return `INSERT INTO ${quoteIdent(table.name)} (${quoted}) VALUES ${values}
      ON CONFLICT (${quoteIdent(SYNC_PARTITION_COLUMN)}, ${quoteIdent(SYNC_ROW_ID_COLUMN)}) DO UPDATE SET ${updates}`;
 }
 
@@ -646,26 +747,40 @@ export function commitWindowPageSql(
 
 /**
  * PostgreSQL set-based form of `scanRowPageSql`: one statement answers the
- * page of every subscription scanning `table` in a pull. `$2` is a JSON array
- * of `{i, tbl, var, vals, after, lim}` records; each record runs the same
- * index-first candidate subquery through a LATERAL join, so every
- * subscription keeps its own keyset cursor and LIMIT. Rows arrive ordered
- * by (i, row_id).
+ * page of every subscription scanning any table in a pull. `$2` is a JSON
+ * array of `{i, tbl, var, vals, after, lim}` records; each record runs the
+ * same index-first candidate subquery through a LATERAL join, so every
+ * subscription keeps its own keyset cursor and LIMIT. The candidate side is
+ * table-agnostic (a spec names its table), so the statement joins the row
+ * table once per table present in the batch through a UNION ALL branch that
+ * keeps only its own candidates. Rows arrive ordered by (i, row_id).
  *
  * Params: [partition, specs (JSON text)]. The specs bind as text before
  * the JSONB cast, so a driver that JSON-encodes a string bound to a `jsonb`
  * parameter (Bun.sql) cannot turn the array into a JSON string.
  */
-export function scanRowBatchSql(table: CompiledTable): string {
-  return `SELECT s.i AS sub, c.row_id AS row_id, r.${quoteIdent(SYNC_VERSION_COLUMN)} AS server_version, r.${quoteIdent(SYNC_SCOPES_COLUMN)} AS scopes, r.${quoteIdent(SYNC_PAYLOAD_COLUMN)} AS payload, r.${quoteIdent(SYNC_COLUMN_VERSIONS_COLUMN)} AS column_versions
-     FROM jsonb_to_recordset($2::text::jsonb) AS s(i int, tbl text, var text, vals text[], after text, lim int)
-     CROSS JOIN LATERAL (SELECT DISTINCT row_id FROM sync_row_scopes
-       WHERE partition=$1 AND tbl=s.tbl AND var=s.var AND value=ANY(s.vals)
-         AND row_id>s.after
-       ORDER BY row_id LIMIT s.lim) c
-     LEFT JOIN ${quoteIdent(table.name)} r
-       ON r.${quoteIdent(SYNC_PARTITION_COLUMN)}=$1 AND r.${quoteIdent(SYNC_ROW_ID_COLUMN)}=c.row_id
-     ORDER BY s.i, c.row_id`;
+export function scanRowBatchSql(tables: readonly CompiledTable[]): string {
+  // One branch per table, each keeping only its own candidates and selecting
+  // the same meta columns so the caller decodes one row shape.
+  const projection = tables
+    .map((table) => {
+      const quoted = quoteIdent(table.name);
+      return `SELECT c.sub AS sub, c.row_id AS row_id, r.${quoteIdent(SYNC_VERSION_COLUMN)} AS server_version, r.${quoteIdent(SYNC_SCOPES_COLUMN)} AS scopes, r.${quoteIdent(SYNC_PAYLOAD_COLUMN)} AS payload, r.${quoteIdent(SYNC_COLUMN_VERSIONS_COLUMN)} AS column_versions
+       FROM cand c
+       LEFT JOIN ${quoted} r
+         ON r.${quoteIdent(SYNC_PARTITION_COLUMN)}=$1 AND r.${quoteIdent(SYNC_ROW_ID_COLUMN)}=c.row_id
+      WHERE c.tbl='${table.name.replaceAll("'", "''")}'`;
+    })
+    .join('\n     UNION ALL ');
+  return `WITH cand AS (
+       SELECT s.i AS sub, c.row_id AS row_id, s.tbl AS tbl
+         FROM jsonb_to_recordset($2::text::jsonb) AS s(i int, tbl text, var text, vals text[], after text, lim int)
+         CROSS JOIN LATERAL (SELECT DISTINCT row_id FROM sync_row_scopes
+           WHERE partition=$1 AND tbl=s.tbl AND var=s.var AND value=ANY(s.vals)
+             AND row_id>s.after
+           ORDER BY row_id LIMIT s.lim) c)
+     ${projection}
+     ORDER BY sub, row_id`;
 }
 
 /**
@@ -958,30 +1073,17 @@ export function selectRowsForRewriteSql(
 }
 
 /**
- * Rewrite one row during a migration: refresh the projection columns (when
+ * SQLite/D1: rewrite one row during a migration: refresh the projection columns (when
  * materialized) and the payload. Bind with `rewriteValues`.
  */
-export function rewriteRowSql(
-  table: CompiledTable,
-  dialect: RelationalDialect,
-): string {
-  const sets: string[] = [];
-  let i = 1;
-  if (table.materialize) {
-    for (const column of table.columns) {
-      sets.push(
-        `${quoteIdent(column.name)}=${dialect === 'sqlite' ? '?' : `$${i}`}`,
-      );
-      i++;
-    }
-  }
-  sets.push(
-    `${quoteIdent(SYNC_PAYLOAD_COLUMN)}=${dialect === 'sqlite' ? '?' : `$${i}`}`,
-  );
-  i++;
-  const wherePartition = dialect === 'sqlite' ? '?' : `$${i}`;
-  const whereRowId = dialect === 'sqlite' ? '?' : `$${i + 1}`;
-  return `UPDATE ${quoteIdent(table.name)} SET ${sets.join(', ')} WHERE ${quoteIdent(SYNC_PARTITION_COLUMN)}=${wherePartition} AND ${quoteIdent(SYNC_ROW_ID_COLUMN)}=${whereRowId}`;
+export function rewriteRowSql(table: CompiledTable): string {
+  const sets = [
+    ...(table.materialize
+      ? table.columns.map((column) => `${quoteIdent(column.name)}=?`)
+      : []),
+    `${quoteIdent(SYNC_PAYLOAD_COLUMN)}=?`,
+  ];
+  return `UPDATE ${quoteIdent(table.name)} SET ${sets.join(', ')} WHERE ${quoteIdent(SYNC_PARTITION_COLUMN)}=? AND ${quoteIdent(SYNC_ROW_ID_COLUMN)}=?`;
 }
 
 /** Bind values for `rewriteRowSql` from the (already migrated) payload. */
@@ -1039,9 +1141,10 @@ export function rewritePlan(
 /**
  * Every DDL statement to bring a database from the introspected relational
  * projections to `schema`: CREATE TABLE for absent tables, ADD COLUMN for
- * missing columns, and rebuild declared secondary indexes. Rebuilding during
- * a version bump supports DROP INDEX and same-name index replacement without
- * requiring historical index definitions in the stored column-layout marker.
+ * missing columns, and the secondary-index diff. An existing Syncular-owned
+ * index stays when the declaration still wants its physical name with the
+ * same {@link indexSignature}; every other owned index is dropped and every
+ * missing one is created, so a bump rebuilds only changed or new indexes.
  *
  * The drop set is limited to Syncular-owned indexes: physical names carrying
  * {@link SYNC_INDEX_PREFIX}, plus bare declared names (databases whose
@@ -1053,17 +1156,30 @@ export function schemaDdl(
   schema: CompiledSchema,
   existingColumnsByTable: ReadonlyMap<string, ReadonlySet<string>>,
   dialect: RelationalDialect,
-  existingIndexesByTable: ReadonlyMap<string, ReadonlySet<string>> = new Map(),
+  existingIndexesByTable: ReadonlyMap<
+    string,
+    ReadonlyMap<string, string>
+  > = new Map(),
 ): string[] {
   const drops: string[] = [];
   const creates: string[] = [];
   for (const table of schema.tables.values()) {
     const existing = existingColumnsByTable.get(table.name);
+    const desired = desiredIndexes(table);
     if (existing === undefined) {
       creates.push(createTableDdl(table, dialect));
     } else {
       const declared = new Set(table.indexes.map((index) => index.name));
-      for (const indexName of existingIndexesByTable.get(table.name) ?? []) {
+      for (const [indexName, signature] of existingIndexesByTable.get(
+        table.name,
+      ) ?? []) {
+        const want = desired.find((index) => index.name === indexName);
+        if (
+          want !== undefined &&
+          (want.signature === undefined || want.signature === signature)
+        ) {
+          continue;
+        }
         if (
           indexName.startsWith(SYNC_INDEX_PREFIX) ||
           declared.has(indexName)
@@ -1073,7 +1189,7 @@ export function schemaDdl(
       }
       creates.push(...addColumnDdl(table, existing, dialect));
     }
-    creates.push(...createIndexDdl(table));
+    creates.push(...desired.map((index) => index.ddl));
   }
   // Every drop precedes every create: an index name moving between tables in
   // one bump must release the global (SQLite) index namespace before the

package/src/schema.ts

@@ -23,6 +23,22 @@ export interface IndexSchema {
   readonly unique?: boolean;
 }
 
+/**
+ * A server-only index on a table's relational projection. Unlike a declared
+ * {@link IndexSchema}, it never reaches a client, and its `columns` are the
+ * physical columns as written: Syncular does not prepend `_sync_partition`.
+ * Name `_sync_partition` and `_sync_row_id` explicitly where an index should
+ * lead with them. The index is never unique, because uniqueness is enforced
+ * per partition. `where` is the predicate of a partial index, in SQL that
+ * the server's dialect accepts. Creating or changing one requires a schema
+ * version bump, like every index.
+ */
+export interface ServerIndexSchema {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly where?: string;
+}
+
 /** One declared reference (§6.11). Absent `onDelete` means `RESTRICT`. */
 export interface ReferenceSchema {
   readonly column: string;
@@ -61,6 +77,8 @@ export interface TableSchema {
   readonly scopes: readonly ScopePatternSpec[];
   /** User indexes (optional) — created on the server's relational tables. */
   readonly indexes?: readonly IndexSchema[];
+  /** Server-only indexes (optional); names share the namespace of `indexes`. */
+  readonly serverIndexes?: readonly ServerIndexSchema[];
   /** Declared references (§6.11). Optional so pre-reference schemas stay
    * valid; the reference index over each child column is declared in
    * `indexes` (typegen emits it). */
@@ -104,6 +122,8 @@ export interface CompiledTable {
   readonly scopePatterns: readonly CompiledScopePattern[];
   /** User indexes (validated: unique names, existing columns). */
   readonly indexes: readonly IndexSchema[];
+  /** Server-only indexes (validated like `indexes`). */
+  readonly serverIndexes: readonly ServerIndexSchema[];
   /** Outgoing declared references (§6.11), resolved to column indices. */
   readonly references: readonly CompiledReference[];
   /** Incoming declared references: child rows to reach on a parent delete. */
@@ -222,6 +242,40 @@ export function compileSchema(schema: ServerSchema): CompiledSchema {
         }
       }
     }
+    const serverIndexes = table.serverIndexes ?? [];
+    for (const index of serverIndexes) {
+      validatePortableRelationalIdentifier(
+        `table ${table.name}: server index`,
+        index.name,
+      );
+      if (indexNames.has(index.name)) {
+        throw new Error(
+          `table ${table.name}: duplicate index ${JSON.stringify(index.name)}`,
+        );
+      }
+      indexNames.add(index.name);
+      if (index.columns.length === 0) {
+        throw new Error(
+          `table ${table.name}: server index ${JSON.stringify(index.name)} must name at least one column`,
+        );
+      }
+      for (const column of index.columns) {
+        if (
+          !columnIndex.has(column) &&
+          column !== '_sync_partition' &&
+          column !== '_sync_row_id'
+        ) {
+          throw new Error(
+            `table ${table.name}: server index ${JSON.stringify(index.name)} names unknown column ${JSON.stringify(column)}`,
+          );
+        }
+      }
+      if (index.where !== undefined && index.where.trim().length === 0) {
+        throw new Error(
+          `table ${table.name}: server index ${JSON.stringify(index.name)} has an empty where predicate`,
+        );
+      }
+    }
     const primaryKeyIndex = columnIndex.get(table.primaryKey);
     if (primaryKeyIndex === undefined) {
       throw new Error(
@@ -319,6 +373,7 @@ export function compileSchema(schema: ServerSchema): CompiledSchema {
       primaryKeyIndex,
       scopePatterns,
       indexes,
+      serverIndexes,
       references,
       referencedBy: [],
       materialize,

package/src/sqlite-bun-driver.ts

@@ -22,7 +22,7 @@ export class BunSqliteDatabase implements SqliteDatabase {
   }
 
   run(sql: string, bindings: readonly SqliteValue[] = []): SqliteRunResult {
-    return this.native.run(sql, [...bindings]);
+    return this.native.query<unknown, SQLQueryBindings[]>(sql).run(...bindings);
   }
 
   query<Row, Params extends readonly SqliteValue[]>(

package/src/sqlite-node-driver.ts

@@ -1,4 +1,8 @@
-import { DatabaseSync, type SQLInputValue } from 'node:sqlite';
+import {
+  DatabaseSync,
+  type SQLInputValue,
+  type StatementSync,
+} from 'node:sqlite';
 import type {
   SqliteDatabase,
   SqliteRunResult,
@@ -16,6 +20,8 @@ function row<Row>(value: Record<string, unknown> | undefined): Row | null {
 
 export class NodeSqliteDatabase implements SqliteDatabase {
   readonly native: DatabaseSync;
+  /** Prepared statements by SQL text, as `bun:sqlite`'s `query` keeps them. */
+  readonly #statements = new Map<string, StatementSync>();
 
   constructor(path = ':memory:') {
     this.native = new DatabaseSync(path);
@@ -26,13 +32,22 @@ export class NodeSqliteDatabase implements SqliteDatabase {
   }
 
   run(sql: string, bindings: readonly SqliteValue[] = []): SqliteRunResult {
-    return this.native.prepare(sql).run(...bindings.map(bind));
+    return this.#prepare(sql).run(...bindings.map(bind));
+  }
+
+  #prepare(sql: string): StatementSync {
+    let statement = this.#statements.get(sql);
+    if (statement === undefined) {
+      statement = this.native.prepare(sql);
+      this.#statements.set(sql, statement);
+    }
+    return statement;
   }
 
   query<Row, Params extends readonly SqliteValue[]>(
     sql: string,
   ): SqliteStatement<Row, Params> {
-    const statement = this.native.prepare(sql);
+    const statement = this.#prepare(sql);
     return {
       run: (...params) => statement.run(...params.map(bind)),
       get: (...params) => row<Row>(statement.get(...params.map(bind))),