@naturalcycles/db-lib 8.46.1 → 8.48.0

package/dist/query/dbQuery.js

@@ -50,6 +50,10 @@ class DBQuery {
         this._filters.push({ name, op: '==', val });
         return this;
     }
+    filterIn(name, val) {
+        this._filters.push({ name, op: 'in', val });
+        return this;
+    }
     limit(limit) {
         this._limitValue = limit;
         return this;
@@ -86,7 +90,7 @@ class DBQuery {
         return this;
     }
     clone() {
-        return Object.assign(new DBQuery(this.table), {
+        return (0, js_lib_1._objectAssign)(new DBQuery(this.table), {
             _filters: [...this._filters],
             _limitValue: this._limitValue,
             _offsetValue: this._offsetValue,
@@ -164,6 +168,9 @@ class RunnableDBQuery extends DBQuery {
     async runQueryCount(opt) {
         return await this.dao.runQueryCount(this, opt);
     }
+    async updateByQuery(patch, opt) {
+        return await this.dao.updateByQuery(this, patch, opt);
+    }
     async streamQueryForEach(mapper, opt) {
         await this.dao.streamQueryForEach(this, mapper, opt);
     }

package/dist/testing/daoTest.js

@@ -48,7 +48,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         // DELETE ALL initially
         test('deleteByIds test items', async () => {
             const rows = await dao.query().select(['id']).runQuery();
-            await db.deleteByIds(test_model_1.TEST_TABLE, rows.map(i => i.id));
+            await db.deleteByQuery(__1.DBQuery.create(test_model_1.TEST_TABLE).filter('id', 'in', rows.map(r => r.id)));
         });
         // QUERY empty
         test('runQuery(all), runQueryCount should return empty', async () => {
@@ -114,7 +114,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
     // GET not empty
     test('getByIds all items', async () => {
         const rows = await dao.getByIds(items.map(i => i.id).concat('abcd'));
-        (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
+        (0, dbTest_1.expectMatch)(expectedItems, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
     });
     // QUERY
     if (querying) {
@@ -187,8 +187,7 @@ function runCommonDaoTest(db, features = {}, quirks = {}) {
         });
         test('cleanup', async () => {
             // CLEAN UP
-            const rows = await dao.query().select(['id']).runQuery();
-            await db.deleteByIds(test_model_1.TEST_TABLE, rows.map(i => i.id));
+            await dao.query().deleteByQuery();
         });
     }
     if (transactions) {

package/dist/testing/dbTest.d.ts

@@ -10,6 +10,8 @@ export interface CommonDBImplementationFeatures {
     dbQuerySelectFields?: boolean;
     insert?: boolean;
     update?: boolean;
+    updateByQuery?: boolean;
+    dbIncrement?: boolean;
     createTable?: boolean;
     tableSchemas?: boolean;
     /**

package/dist/testing/dbTest.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectMatch = exports.runCommonDBTest = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
+const db_model_1 = require("../db.model");
 const dbQuery_1 = require("../query/dbQuery");
 const dbTransaction_1 = require("../transaction/dbTransaction");
 const test_model_1 = require("./test.model");
@@ -13,7 +14,7 @@ const test_util_1 = require("./test.util");
 function runCommonDBTest(db, features = {}, quirks = {}) {
     const { querying = true, tableSchemas = true, createTable = true, dbQueryFilter = true, 
     // dbQueryFilterIn = true,
-    dbQueryOrder = true, dbQuerySelectFields = true, insert = true, update = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, documentDB = true, transactions = true, } = features;
+    dbQueryOrder = true, dbQuerySelectFields = true, insert = true, update = true, updateByQuery = true, dbIncrement = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, documentDB = true, transactions = true, } = features;
     // const {
     // allowExtraPropertiesInResponse,
     // allowBooleansAsUndefined,
@@ -36,7 +37,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
         // DELETE ALL initially
         test('deleteByIds test items', async () => {
             const { rows } = await db.runQuery(queryAll().select(['id']));
-            await db.deleteByIds(test_model_1.TEST_TABLE, rows.map(i => i.id));
+            await db.runQuery(queryAll().filter('id', 'in', rows.map(i => i.id)));
         });
         // QUERY empty
         test('runQuery(all), runQueryCount should return empty', async () => {
@@ -48,15 +49,15 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     }
     // GET empty
     test('getByIds(item1.id) should return empty', async () => {
-        const [item1Loaded] = await db.getByIds(test_model_1.TEST_TABLE, [item1.id]);
+        const [item1Loaded] = (await db.runQuery(queryAll().filterEq('id', item1.id))).rows;
         // console.log(a)
         expect(item1Loaded).toBeUndefined();
     });
     test('getByIds([]) should return []', async () => {
-        expect(await db.getByIds(test_model_1.TEST_TABLE, [])).toEqual([]);
+        expect((await db.runQuery(queryAll().filter('id', 'in', []))).rows).toEqual([]);
     });
     test('getByIds(...) should return empty', async () => {
-        expect(await db.getByIds(test_model_1.TEST_TABLE, ['abc', 'abcd'])).toEqual([]);
+        expect((await db.runQuery(queryAll().filter('id', 'in', ['abc', 'abcd']))).rows).toEqual([]);
     });
     // SAVE
     if (nullValues) {
@@ -67,7 +68,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             };
             (0, test_util_1.deepFreeze)(item3);
             await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
-            const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
+            const item3Loaded = (await db.runQuery(queryAll().filterEq('id', item3.id))).rows[0];
             expectMatch([item3], [item3Loaded], quirks);
             expect(item3Loaded.k2).toBeNull();
         });
@@ -82,7 +83,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             const expected = { ...item3 };
             delete expected.k2;
             await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
-            const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
+            const item3Loaded = (await db.runQuery(queryAll().filterEq('id', item3.id))).rows[0];
             expectMatch([expected], [item3Loaded], quirks);
             expect(item3Loaded.k2).toBeUndefined();
             expect(Object.keys(item3Loaded)).not.toContain('k2');
@@ -111,8 +112,8 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
     }
     // GET not empty
     test('getByIds all items', async () => {
-        const rows = await db.getByIds(test_model_1.TEST_TABLE, items.map(i => i.id).concat('abcd'));
-        expectMatch(items, rows, quirks);
+        const rows = (await db.runQuery(queryAll().filter('id', 'in', items.map(i => i.id).concat('abcd')))).rows;
+        expectMatch(items, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
     });
     // QUERY
     if (querying) {
@@ -203,7 +204,7 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
                 b1,
             };
             await db.saveBatch(test_model_1.TEST_TABLE, [item]);
-            const [loaded] = await db.getByIds(test_model_1.TEST_TABLE, [item.id]);
+            const loaded = (await db.runQuery(queryAll().filterEq('id', item.id))).rows[0];
             const b1Loaded = loaded.b1;
             // console.log({
             //   b11: typeof b1,
@@ -245,11 +246,50 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             expectMatch(expected, rows, quirks);
         });
     }
+    if (updateByQuery) {
+        test('updateByQuery simple', async () => {
+            // cleanup, reset initial data
+            await db.deleteByQuery(queryAll());
+            await db.saveBatch(test_model_1.TEST_TABLE, items);
+            const patch = {
+                k3: 5,
+                k2: 'abc',
+            };
+            await db.updateByQuery(dbQuery_1.DBQuery.create(test_model_1.TEST_TABLE).filterEq('even', true), patch);
+            const { rows } = await db.runQuery(queryAll());
+            const expected = items.map(r => {
+                if (r.even) {
+                    return { ...r, ...patch };
+                }
+                return r;
+            });
+            expectMatch(expected, rows, quirks);
+        });
+        if (dbIncrement) {
+            test('updateByQuery DBIncrement', async () => {
+                // cleanup, reset initial data
+                await db.deleteByQuery(queryAll());
+                await db.saveBatch(test_model_1.TEST_TABLE, items);
+                const patch = {
+                    k3: db_model_1.DBIncrement.of(1),
+                    k2: 'abcd',
+                };
+                await db.updateByQuery(dbQuery_1.DBQuery.create(test_model_1.TEST_TABLE).filterEq('even', true), patch);
+                const { rows } = await db.runQuery(queryAll());
+                const expected = items.map(r => {
+                    if (r.even) {
+                        return { ...r, ...patch, k3: (r.k3 || 0) + 1 };
+                    }
+                    return r;
+                });
+                expectMatch(expected, rows, quirks);
+            });
+        }
+    }
     if (querying) {
         test('cleanup', async () => {
             // CLEAN UP
-            const { rows } = await db.runQuery(queryAll().select(['id']));
-            await db.deleteByIds(test_model_1.TEST_TABLE, rows.map(i => i.id));
+            await db.deleteByQuery(queryAll());
         });
     }
 }

package/dist/transaction/dbTransaction.util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commitDBTransactionSimple = exports.mergeDBOperations = void 0;
+const dbQuery_1 = require("../query/dbQuery");
 /**
  * Optimizes the Transaction (list of DBOperations) to do less operations.
  * E.g if you save id1 first and then delete it - this function will turn it into a no-op (self-eliminate).
@@ -74,7 +75,10 @@ async function commitDBTransactionSimple(db, tx, opt) {
             await db.saveBatch(op.table, op.rows, { ...op.opt, ...opt });
         }
         else if (op.type === 'deleteByIds') {
-            await db.deleteByIds(op.table, op.ids, { ...op.opt, ...opt });
+            await db.deleteByQuery(dbQuery_1.DBQuery.create(op.table).filter('id', 'in', op.ids), {
+                ...op.opt,
+                ...opt,
+            });
         }
         else {
             throw new Error(`DBOperation not supported: ${op.type}`);

package/package.json

@@ -41,7 +41,7 @@
   "engines": {
     "node": ">=14.15"
   },
-  "version": "8.46.1",
+  "version": "8.48.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/cachedb/cache.db.ts

@@ -1,13 +1,8 @@
 import { Readable } from 'node:stream'
-import {
-  JsonSchemaObject,
-  JsonSchemaRootObject,
-  ObjectWithId,
-  StringMap,
-} from '@naturalcycles/js-lib'
+import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib'
 import { BaseCommonDB } from '../../base.common.db'
 import { CommonDB } from '../../common.db'
-import { CommonDBOptions, RunQueryResult } from '../../db.model'
+import { CommonDBOptions, DBPatch, RunQueryResult } from '../../db.model'
 import { DBQuery } from '../../query/dbQuery'
 import { DBTransaction } from '../../transaction/dbTransaction'
 import {
@@ -72,81 +67,6 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     }
   }
 
-  override async getByIds<ROW extends ObjectWithId>(
-    table: string,
-    ids: ROW['id'][],
-    opt: CacheDBSaveOptions<ROW> = {},
-  ): Promise<ROW[]> {
-    const resultMap: StringMap<ROW> = {}
-    const missingIds: ROW['id'][] = []
-
-    if (!opt.skipCache && !this.cfg.skipCache) {
-      const results = await this.cfg.cacheDB.getByIds<ROW>(table, ids, opt)
-
-      results.forEach(r => (resultMap[r.id] = r))
-
-      missingIds.push(...ids.filter(id => !resultMap[id]))
-
-      if (this.cfg.logCached) {
-        this.cfg.logger?.log(
-          `${table}.getByIds ${results.length} rows from cache: [${results
-            .map(r => r.id)
-            .join(', ')}]`,
-        )
-      }
-    }
-
-    if (missingIds.length && !opt.onlyCache && !this.cfg.onlyCache) {
-      const results = await this.cfg.downstreamDB.getByIds<ROW>(table, missingIds, opt)
-      results.forEach(r => (resultMap[r.id] = r))
-
-      if (this.cfg.logDownstream) {
-        this.cfg.logger?.log(
-          `${table}.getByIds ${results.length} rows from downstream: [${results
-            .map(r => r.id)
-            .join(', ')}]`,
-        )
-      }
-
-      if (!opt.skipCache) {
-        const cacheResult = this.cfg.cacheDB.saveBatch(table, results, opt)
-        if (this.cfg.awaitCache) await cacheResult
-      }
-    }
-
-    // return in right order
-    return ids.map(id => resultMap[id]!).filter(Boolean)
-  }
-
-  override async deleteByIds<ROW extends ObjectWithId>(
-    table: string,
-    ids: ROW['id'][],
-    opt: CacheDBOptions = {},
-  ): Promise<number> {
-    let deletedIds = 0
-
-    if (!opt.onlyCache && !this.cfg.onlyCache) {
-      deletedIds = await this.cfg.downstreamDB.deleteByIds<ROW>(table, ids, opt)
-
-      if (this.cfg.logDownstream) {
-        this.cfg.logger?.log(`${table}.deleteByIds ${deletedIds} rows from downstream`)
-      }
-    }
-
-    if (!opt.skipCache && !this.cfg.skipCache) {
-      const cacheResult = this.cfg.cacheDB
-        .deleteByIds<ROW>(table, ids, opt)
-        .then(deletedFromCache => {
-          if (this.cfg.logCached) {
-            this.cfg.logger?.log(`${table}.deleteByIds ${deletedFromCache} rows from cache`)
-          }
-        })
-      if (this.cfg.awaitCache) await cacheResult
-    }
-
-    return deletedIds
-  }
-
   override async saveBatch<ROW extends Partial<ObjectWithId>>(
     table: string,
     rows: ROW[],
@@ -294,6 +214,25 @@ export class CacheDB extends BaseCommonDB implements CommonDB {
     return deletedIds
   }
 
+  override async updateByQuery<ROW extends ObjectWithId>(
+    q: DBQuery<ROW>,
+    patch: DBPatch<ROW>,
+    opt: CacheDBOptions = {},
+  ): Promise<number> {
+    let updated: number | undefined
+
+    if (!opt.onlyCache && !this.cfg.onlyCache) {
+      updated = await this.cfg.downstreamDB.updateByQuery(q, patch, opt)
+    }
+
+    if (!opt.skipCache && !this.cfg.skipCache) {
+      const cacheResult = this.cfg.cacheDB.updateByQuery(q, patch, opt)
+      if (this.cfg.awaitCache) updated ??= await cacheResult
+    }
+
+    return updated || 0
+  }
+
   override async commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void> {
     await this.cfg.downstreamDB.commitTransaction(tx, opt)
     await this.cfg.cacheDB.commitTransaction(tx, opt)

package/src/adapter/file/file.db.ts

@@ -65,15 +65,6 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     return tables
   }
 
-  override async getByIds<ROW extends ObjectWithId>(
-    table: string,
-    ids: ROW['id'][],
-    _opt?: CommonDBOptions,
-  ): Promise<ROW[]> {
-    const byId = _by(await this.loadFile<ROW>(table), r => r.id)
-    return ids.map(id => byId[id]!).filter(Boolean)
-  }
-
   override async saveBatch<ROW extends Partial<ObjectWithId>>(
     table: string,
     rows: ROW[],
@@ -198,29 +189,6 @@ export class FileDB extends BaseCommonDB implements CommonDB {
     return readable
   }
 
-  override async deleteByIds<ROW extends ObjectWithId>(
-    table: string,
-    ids: ROW['id'][],
-    _opt?: CommonDBOptions,
-  ): Promise<number> {
-    if (!ids.length) return 0
-
-    let deleted = 0
-    const rows = (await this.loadFile<ROW>(table)).filter(r => {
-      if (ids.includes(r.id)) {
-        deleted++
-        return false
-      }
-      return true
-    })
-
-    if (deleted > 0) {
-      await this.saveFile(table, rows)
-    }
-
-    return deleted
-  }
-
   override async deleteByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
     _opt?: CommonDBOptions,

package/src/adapter/inmemory/inMemory.db.ts

@@ -13,6 +13,7 @@ import {
   _stringMapValues,
   CommonLogger,
   _deepCopy,
+  _assert,
 } from '@naturalcycles/js-lib'
 import {
   bufferReviver,
@@ -25,7 +26,7 @@ import {
 } from '@naturalcycles/nodejs-lib'
 import { dimGrey, yellow } from '@naturalcycles/nodejs-lib/dist/colors'
 import * as fs from 'fs-extra'
-import { CommonDB, DBTransaction, queryInMemory } from '../..'
+import { CommonDB, DBIncrement, DBPatch, DBTransaction, queryInMemory } from '../..'
 import {
   CommonDBCreateOptions,
   CommonDBOptions,
@@ -142,16 +143,6 @@ export class InMemoryDB implements CommonDB {
     }
   }
 
-  async getByIds<ROW extends ObjectWithId>(
-    _table: string,
-    ids: ROW['id'][],
-    _opt?: CommonDBOptions,
-  ): Promise<ROW[]> {
-    const table = this.cfg.tablesPrefix + _table
-    this.data[table] ||= {}
-    return ids.map(id => this.data[table]![id]).filter(Boolean) as ROW[]
-  }
-
   async saveBatch<ROW extends Partial<ObjectWithId>>(
     _table: string,
     rows: ROW[],
@@ -183,31 +174,41 @@ export class InMemoryDB implements CommonDB {
     })
   }
 
-  async deleteByIds<ROW extends ObjectWithId>(
-    _table: string,
-    ids: ROW['id'][],
+  async deleteByQuery<ROW extends ObjectWithId>(
+    q: DBQuery<ROW>,
     _opt?: CommonDBOptions,
   ): Promise<number> {
-    const table = this.cfg.tablesPrefix + _table
+    const table = this.cfg.tablesPrefix + q.table
     this.data[table] ||= {}
-
-    return ids
-      .map(id => {
-        const exists = !!this.data[table]![id]
-        delete this.data[table]![id]
-        if (exists) return id
-      })
-      .filter(Boolean).length
+    let count = 0
+    queryInMemory(q, Object.values(this.data[table] || {}) as ROW[]).forEach(r => {
+      if (!this.data[table]![r.id]) return
+      delete this.data[table]![r.id]
+      count++
+    })
+    return count
   }
 
-  async deleteByQuery<ROW extends ObjectWithId>(
+  async updateByQuery<ROW extends ObjectWithId>(
     q: DBQuery<ROW>,
-    _opt?: CommonDBOptions,
+    patch: DBPatch<ROW>,
   ): Promise<number> {
+    const patchEntries = Object.entries(patch)
+    if (!patchEntries.length) return 0
+
     const table = this.cfg.tablesPrefix + q.table
     const rows = queryInMemory(q, Object.values(this.data[table] || {}) as ROW[])
-    const ids = rows.map(r => r.id)
-    return await this.deleteByIds(q.table, ids)
+    rows.forEach((row: any) => {
+      patchEntries.forEach(([k, v]) => {
+        if (v instanceof DBIncrement) {
+          row[k] = (row[k] || 0) + v.amount
+        } else {
+          row[k] = v
+        }
+      })
+    })
+
+    return rows.length
   }
 
   async runQuery<ROW extends ObjectWithId>(
@@ -242,7 +243,10 @@ export class InMemoryDB implements CommonDB {
         if (op.type === 'saveBatch') {
           await this.saveBatch(op.table, op.rows, { ...op.opt, ...opt })
         } else if (op.type === 'deleteByIds') {
-          await this.deleteByIds(op.table, op.ids, { ...op.opt, ...opt })
+          await this.deleteByQuery(DBQuery.create(op.table).filter('id', 'in', op.ids), {
+            ...op.opt,
+            ...opt,
+          })
         } else {
           throw new Error(`DBOperation not supported: ${(op as any).type}`)
         }
@@ -260,9 +264,7 @@ export class InMemoryDB implements CommonDB {
    * Flushes all tables (all namespaces) at once.
    */
   async flushToDisk(): Promise<void> {
-    if (!this.cfg.persistenceEnabled) {
-      throw new Error('flushToDisk() called but persistenceEnabled=false')
-    }
+    _assert(this.cfg.persistenceEnabled, 'flushToDisk() called but persistenceEnabled=false')
     const { persistentStoragePath, persistZip } = this.cfg
 
     const started = Date.now()
@@ -297,9 +299,7 @@ export class InMemoryDB implements CommonDB {
    * Restores all tables (all namespaces) at once.
    */
   async restoreFromDisk(): Promise<void> {
-    if (!this.cfg.persistentStoragePath) {
-      throw new Error('restoreFromDisk() called but persistenceEnabled=false')
-    }
+    _assert(this.cfg.persistenceEnabled, 'restoreFromDisk() called but persistenceEnabled=false')
     const { persistentStoragePath } = this.cfg
 
     const started = Date.now()

package/src/base.common.db.ts

@@ -1,68 +1,68 @@
-import { Readable } from 'node:stream'
 import { JsonSchemaObject, JsonSchemaRootObject, ObjectWithId } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { CommonDB } from './common.db'
-import { CommonDBOptions, CommonDBSaveOptions, RunQueryResult } from './db.model'
+import { CommonDBOptions, CommonDBSaveOptions, DBPatch, RunQueryResult } from './db.model'
 import { DBQuery } from './query/dbQuery'
 import { DBTransaction } from './transaction/dbTransaction'
-import { commitDBTransactionSimple } from './transaction/dbTransaction.util'
+
+/* eslint-disable unused-imports/no-unused-vars */
 
 /**
  * No-op implementation of CommonDB interface.
  * To be extended by actual implementations.
  */
 export class BaseCommonDB implements CommonDB {
-  async ping(): Promise<void> {}
+  async ping(): Promise<void> {
+    throw new Error('ping is not implemented')
+  }
 
   async getTables(): Promise<string[]> {
-    return []
+    throw new Error('getTables is not implemented')
   }
 
   async getTableSchema<ROW extends ObjectWithId>(
     table: string,
   ): Promise<JsonSchemaRootObject<ROW>> {
-    return {
-      $id: `${table}.schema.json`,
-      type: 'object',
-      additionalProperties: true,
-      properties: {} as any,
-      required: [],
-    }
+    throw new Error('getTableSchema is not implemented')
   }
 
   async createTable<ROW extends ObjectWithId>(
-    _table: string,
-    _schema: JsonSchemaObject<ROW>,
-  ): Promise<void> {}
-
-  async deleteByIds<ROW extends ObjectWithId>(_table: string, _ids: ROW['id'][]): Promise<number> {
-    return 0
+    table: string,
+    schema: JsonSchemaObject<ROW>,
+  ): Promise<void> {
+    // no-op
   }
 
-  async deleteByQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number> {
-    return 0
+  async deleteByQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number> {
+    throw new Error('deleteByQuery is not implemented')
   }
 
-  async getByIds<ROW extends ObjectWithId>(_table: string, _ids: ROW['id'][]): Promise<ROW[]> {
-    return []
+  async updateByQuery<ROW extends ObjectWithId>(
+    q: DBQuery<ROW>,
+    patch: DBPatch<ROW>,
+    opt?: CommonDBOptions,
+  ): Promise<number> {
+    throw new Error('updateByQuery is not implemented')
   }
 
-  async runQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<RunQueryResult<ROW>> {
-    return { rows: [] }
+  async runQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<RunQueryResult<ROW>> {
+    throw new Error('runQuery is not implemented')
   }
 
-  async runQueryCount<ROW extends ObjectWithId>(_q: DBQuery<ROW>): Promise<number> {
-    return 0
+  async runQueryCount<ROW extends ObjectWithId>(q: DBQuery<ROW>): Promise<number> {
+    throw new Error('runQueryCount is not implemented')
   }
 
   async saveBatch<ROW extends Partial<ObjectWithId>>(
-    _table: string,
-    _rows: ROW[],
-    _opt?: CommonDBSaveOptions<ROW>,
-  ): Promise<void> {}
+    table: string,
+    rows: ROW[],
+    opt?: CommonDBSaveOptions<ROW>,
+  ): Promise<void> {
+    throw new Error('saveBatch is not implemented')
+  }
 
-  streamQuery<ROW extends ObjectWithId>(_q: DBQuery<ROW>): ReadableTyped<ROW> {
-    return Readable.from([])
+  streamQuery<ROW extends ObjectWithId>(q: DBQuery<ROW>): ReadableTyped<ROW> {
+    throw new Error('streamQuery is not implemented')
   }
 
   /**
@@ -71,6 +71,6 @@ export class BaseCommonDB implements CommonDB {
    * To be extended.
    */
   async commitTransaction(tx: DBTransaction, opt?: CommonDBOptions): Promise<void> {
-    await commitDBTransactionSimple(this, tx, opt)
+    throw new Error('commitTransaction is not implemented')
   }
 }