Run queries on read-only connections when we can.

Author: rkistner

packages/drizzle-driver/src/sqlite/PowerSyncSQLiteBaseSession.ts

@@ -1,4 +1,5 @@
 import { LockContext, QueryResult } from '@powersync/common';
+import type { WithCacheConfig } from 'drizzle-orm/cache/core/types';
 import { entityKind } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
 import { NoopLogger } from 'drizzle-orm/logger';
@@ -14,6 +15,7 @@ import {
   type SQLiteTransactionConfig
 } from 'drizzle-orm/sqlite-core/session';
 import { PowerSyncSQLitePreparedQuery } from './PowerSyncSQLitePreparedQuery.js';
+import { QueryContext } from './QueryContext.js';
 
 export interface PowerSyncSQLiteSessionOptions {
   logger?: Logger;
@@ -39,7 +41,7 @@ export class PowerSyncSQLiteBaseSession<
   protected logger: Logger;
 
   constructor(
-    protected db: LockContext,
+    protected db: QueryContext,
     protected dialect: SQLiteAsyncDialect,
     protected schema: RelationalSchemaConfig<TSchema> | undefined,
     protected options: PowerSyncSQLiteSessionOptions = {}
@@ -53,7 +55,12 @@ export class PowerSyncSQLiteBaseSession<
     fields: SelectedFieldsOrdered | undefined,
     executeMethod: SQLiteExecuteMethod,
     isResponseInArrayMode: boolean,
-    customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown
+    customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown,
+    queryMetadata?: {
+      type: 'select' | 'update' | 'delete' | 'insert';
+      tables: string[];
+    },
+    cacheConfig?: WithCacheConfig
   ): PowerSyncSQLitePreparedQuery<T> {
     return new PowerSyncSQLitePreparedQuery(
       this.db,
@@ -62,7 +69,10 @@ export class PowerSyncSQLiteBaseSession<
       fields,
       executeMethod,
       isResponseInArrayMode,
-      customResultMapper
+      customResultMapper,
+      undefined, // cache not supported yet
+      queryMetadata,
+      cacheConfig
     );
   }
 

packages/drizzle-driver/src/sqlite/PowerSyncSQLitePreparedQuery.ts

@@ -1,5 +1,7 @@
-import { LockContext, QueryResult } from '@powersync/common';
+import { QueryResult } from '@powersync/common';
 import { Column, DriverValueDecoder, getTableName, SQL } from 'drizzle-orm';
+import type { Cache } from 'drizzle-orm/cache/core';
+import type { WithCacheConfig } from 'drizzle-orm/cache/core/types';
 import { entityKind, is } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
 import { fillPlaceholders, type Query } from 'drizzle-orm/sql/sql';
@@ -10,6 +12,7 @@ import {
   type SQLiteExecuteMethod,
   SQLitePreparedQuery
 } from 'drizzle-orm/sqlite-core/session';
+import { QueryContext } from './QueryContext.js';
 
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
 
@@ -25,16 +28,27 @@ export class PowerSyncSQLitePreparedQuery<
 }> {
   static readonly [entityKind]: string = 'PowerSyncSQLitePreparedQuery';
 
+  private readOnly = false;
+
   constructor(
-    private db: LockContext,
+    private db: QueryContext,
     query: Query,
     private logger: Logger,
     private fields: SelectedFieldsOrdered | undefined,
     executeMethod: SQLiteExecuteMethod,
     private _isResponseInArrayMode: boolean,
-    private customResultMapper?: (rows: unknown[][]) => unknown
+    private customResultMapper?: (rows: unknown[][]) => unknown,
+    cache?: Cache | undefined,
+    queryMetadata?:
+      | {
+          type: 'select' | 'update' | 'delete' | 'insert';
+          tables: string[];
+        }
+      | undefined,
+    cacheConfig?: WithCacheConfig | undefined
   ) {
-    super('async', executeMethod, query);
+    super('async', executeMethod, query, cache, queryMetadata, cacheConfig);
+    this.readOnly = queryMetadata?.type == 'select';
   }
 
   async run(placeholderValues?: Record<string, unknown>): Promise<QueryResult> {
@@ -90,6 +104,13 @@ export class PowerSyncSQLitePreparedQuery<
     const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
     this.logger.logQuery(this.query.sql, params);
 
+    // When calling on the database (not in a transaction), and this is a select/read-only query,
+    // use a read context for the query.
+    if (this.readOnly) {
+      return this.db.getAllRaw(this.query.sql, params);
+    }
+
+    // This uses a write lock, unless we're already in a read transaction
     return await this.db.executeRaw(this.query.sql, params);
   }
 

packages/drizzle-driver/src/sqlite/PowerSyncSQLiteSession.ts

@@ -8,6 +8,7 @@ import {
   PowerSyncSQLiteTransaction,
   PowerSyncSQLiteTransactionConfig
 } from './PowerSyncSQLiteBaseSession.js';
+import { DatabaseQueryContext, LockQueryContext } from './QueryContext.js';
 
 export class PowerSyncSQLiteSession<
   TFullSchema extends Record<string, unknown>,
@@ -21,7 +22,7 @@ export class PowerSyncSQLiteSession<
     schema: RelationalSchemaConfig<TSchema> | undefined,
     options: PowerSyncSQLiteSessionOptions = {}
   ) {
-    super(db, dialect, schema, options);
+    super(new DatabaseQueryContext(db), dialect, schema, options);
     this.client = db;
   }
 
@@ -46,7 +47,7 @@ export class PowerSyncSQLiteSession<
     const tx = new PowerSyncSQLiteTransaction<TFullSchema, TSchema>(
       'async',
       (this as any).dialect,
-      new PowerSyncSQLiteBaseSession(connection, this.dialect, this.schema, this.options),
+      new PowerSyncSQLiteBaseSession(new LockQueryContext(connection), this.dialect, this.schema, this.options),
       this.schema
     );
 

packages/drizzle-driver/src/sqlite/QueryContext.ts

@@ -0,0 +1,58 @@
+import { AbstractPowerSyncDatabase, LockContext, QueryResult } from '@powersync/common';
+
+/**
+ * Like LockContext, but only includes the specific methods needed for Drizzle.
+ *
+ * We extend it by adding getAllRaw, to support read-only queries with executeRaw.
+ */
+export interface QueryContext {
+  execute(query: string, params?: any[] | undefined): Promise<QueryResult>;
+  executeRaw(query: string, params?: any[] | undefined): Promise<any[][]>;
+
+  get<T>(sql: string, parameters?: any[]): Promise<T>;
+  getAll<T>(sql: string, parameters?: any[]): Promise<T[]>;
+  /**
+   * Like executeRaw, but for read-only queries.
+   */
+  getAllRaw(query: string, params?: any[] | undefined): Promise<any[][]>;
+}
+
+export class DatabaseQueryContext implements QueryContext {
+  constructor(private db: AbstractPowerSyncDatabase) {}
+  execute(query: string, params?: any[] | undefined): Promise<QueryResult> {
+    return this.db.execute(query, params);
+  }
+  executeRaw(query: string, params?: any[] | undefined) {
+    return this.db.executeRaw(query, params);
+  }
+  get<T>(sql: string, parameters?: any[]) {
+    return this.db.get<T>(sql, parameters);
+  }
+  getAll<T>(sql: string, parameters?: any[]) {
+    return this.db.getAll<T>(sql, parameters);
+  }
+  getAllRaw(query: string, params?: any[] | undefined) {
+    return this.db.readLock(async (ctx) => {
+      return ctx.executeRaw(query, params);
+    });
+  }
+}
+
+export class LockQueryContext implements QueryContext {
+  constructor(private ctx: LockContext) {}
+  execute(query: string, params?: any[] | undefined): Promise<QueryResult> {
+    return this.ctx.execute(query, params);
+  }
+  executeRaw(query: string, params?: any[] | undefined) {
+    return this.ctx.executeRaw(query, params);
+  }
+  get<T>(sql: string, parameters?: any[]) {
+    return this.ctx.get<T>(sql, parameters);
+  }
+  getAll<T>(sql: string, parameters?: any[]) {
+    return this.ctx.getAll<T>(sql, parameters);
+  }
+  getAllRaw(query: string, params?: any[] | undefined) {
+    return this.ctx.executeRaw(query, params);
+  }
+}