fhirsmith 0.18.2 → 1.0.0

package/tx/vs/vs-database.js

@@ -3,9 +3,15 @@ const crypto = require('crypto');
 const sqlite3 = require('sqlite3').verbose();
 const { VersionUtilities } = require('../../library/version-utilities');
 const ValueSet = require("../library/valueset");
+const { guarded } = require('../library/sqlite-utilities');
+// the server log ({tx}), looked up when used (the database is opened by importers and tests too)
+const txLog = () => require('../../library/logger').getInstance().child({ module: 'tx' });
 
 // Settings key written once a package cache has been fully populated (see isComplete)
 const CACHE_COMPLETE_KEY = 'cache-complete';
+// A counter in vsac_settings that the VSAC sync bumps when it has written (cluster.md):
+// a process that loaded the value set list at generation n is up to date while it says n
+const GENERATION_KEY = 'generation';
 
 // Columns that can be returned directly without parsing JSON
 const INDEXED_COLUMNS = ['id', 'url', 'version', 'date', 'description', 'name', 'publisher', 'status', 'title'];
@@ -41,11 +47,22 @@ function isNewerVersion(candidate, current) {
 class ValueSetDatabase {
   vsCount;
 
+  // search() can build results with these elements from the table's columns
+  static INDEXED_COLUMNS = INDEXED_COLUMNS;
+
   /**
    * @param {string} dbPath - Path to the SQLite database file
+   * @param {Object} [options] - {shared: true} when several processes use the file (one
+   *   writing, the others reading - cluster.md): WAL, so the readers don't block the writer,
+   *   and a wait of up to 5 s for another process's lock instead of failing at once.
+   *   {readOnly: true} for a cache another process builds (a tx-worker's package caches,
+   *   cluster.md): opened read-only, never created or migrated - a file that still needs a
+   *   migration fails to open (see _checkFinal), to be tried again once its builder is done
    */
-  constructor(dbPath) {
+  constructor(dbPath, options = {}) {
     this.dbPath = dbPath;
+    this.shared = !!options.shared;
+    this.readOnly = !!options.readOnly;
     // Single read-write connection used for everything. Using a separate
     // OPEN_READONLY connection for reads can miss WAL-based schema changes
     // made through the write connection (because read-only opens can't fully
@@ -69,13 +86,17 @@ class ValueSetDatabase {
     // table_info` can race ahead of a `CREATE TABLE IF NOT EXISTS`, and
     // you get "no such table" errors on DDL that should have been fine.
     const run = (sql) => new Promise((res, rej) => {
-      db.run(sql, [], (err) => err ? rej(err) : res());
+      db.run(sql, [], guarded(rej, (err) => err ? rej(err) : res()));
     });
     const all = (sql) => new Promise((res, rej) => {
-      db.all(sql, [], (err, rows) => err ? rej(err) : res(rows));
+      db.all(sql, [], guarded(rej, (err, rows) => err ? rej(err) : res(rows)));
     });
 
     return (async () => {
+      if (this.shared) {
+        db.configure('busyTimeout', 5000);
+        await all('PRAGMA journal_mode = WAL');
+      }
       const cols = await all("PRAGMA table_info(valuesets)");
       const hasDateFirstSeen = cols.some(c => c.name === 'date_first_seen');
       const hasContentHash = cols.some(c => c.name === 'content_hash');
@@ -138,7 +159,7 @@ class ValueSetDatabase {
       );
       const missing = (needHash[0] && needHash[0].n) || 0;
       if (missing > 0) {
-        console.log(`Backfilling content_hash for ${missing} existing value sets...`);
+        txLog().info(`Backfilling content_hash for ${missing} existing value sets...`);
         const rows = await all(
             "SELECT id, content FROM valuesets WHERE content_hash IS NULL"
         );
@@ -149,15 +170,15 @@ class ValueSetDatabase {
             db.run(
                 'UPDATE valuesets SET content_hash = ? WHERE id = ?',
                 [hash, row.id],
-                (err) => err ? rej(err) : res()
+                guarded(rej, (err) => err ? rej(err) : res())
             );
           });
           done++;
           if (done % 1000 === 0) {
-            console.log(`  ...${done}/${missing}`);
+            txLog().info(`  ...${done}/${missing}`);
           }
         }
-        console.log(`Backfilled ${done} hashes.`);
+        txLog().info(`Backfilled ${done} hashes.`);
       }
     })();
   }
@@ -194,25 +215,92 @@ class ValueSetDatabase {
     if (this._migrationPromise) {
       return this._migrationPromise;
     }
+    if (this.readOnly) {
+      return this._openReadOnly();
+    }
     this._migrationPromise = new Promise((resolve, reject) => {
       if (this._writeDb) {
         this._migrateIfNeeded(this._writeDb).then(resolve).catch(reject);
         return;
       }
-      this._writeDb = new sqlite3.Database(this.dbPath, (err) => {
+      this._writeDb = new sqlite3.Database(this.dbPath, guarded(reject, (err) => {
         if (err) {
           this._writeDb = null;
           reject(new Error(`Failed to open database for writing: ${err.message}`));
           return;
         }
         this._migrateIfNeeded(this._writeDb).then(resolve).catch(reject);
-      });
+      }));
     });
     // If migration fails, clear the cached promise so a retry can attempt again
     this._migrationPromise.catch(() => { this._migrationPromise = null; });
     return this._migrationPromise;
   }
 
+  /**
+   * readOnly: open the file read-only, and check it needs no migration. On failure the
+   * connection is closed (the next use opens it again: the builder may have replaced it)
+   * @returns {Promise<void>}
+   * @private
+   */
+  _openReadOnly() {
+    this._migrationPromise = new Promise((resolve, reject) => {
+      const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, (err) => {
+        if (err) {
+          reject(new Error(`Failed to open database ${this.dbPath} read-only: ${err.message}`));
+          return;
+        }
+        db.configure('busyTimeout', 5000);
+        this._checkFinal(db).then(() => {
+          this._writeDb = db;
+          resolve();
+        }, (error) => {
+          db.close(() => reject(error));
+        });
+      });
+    });
+    this._migrationPromise.catch(() => { this._migrationPromise = null; });
+    return this._migrationPromise;
+  }
+
+  /**
+   * Reject unless the file is as _migrateIfNeeded leaves it: every column and table there,
+   * and no row without its content_hash
+   * @param {sqlite3.Database} db
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _checkFinal(db) {
+    const all = (sql) => new Promise((res, rej) => {
+      db.all(sql, [], (err, rows) => err ? rej(err) : res(rows));
+    });
+    const columns = async (table) => (await all(`PRAGMA table_info(${table})`)).map(c => c.name);
+    const vsCols = await columns('valuesets');
+    const pending = [];
+    for (const col of ['date_first_seen', 'content_hash']) {
+      if (!vsCols.includes(col)) {
+        pending.push(`valuesets.${col}`);
+      }
+    }
+    if (!(await columns('vsac_runs')).includes('total_updated')) {
+      pending.push('vsac_runs.total_updated');
+    }
+    for (const table of ['vsac_settings', 'vsac_events']) {
+      if ((await columns(table)).length === 0) {
+        pending.push(table);
+      }
+    }
+    if (pending.length === 0) {
+      const rows = await all('SELECT COUNT(*) AS n FROM valuesets WHERE content_hash IS NULL');
+      if (rows[0] && rows[0].n > 0) {
+        pending.push(`content_hash of ${rows[0].n} value sets`);
+      }
+    }
+    if (pending.length > 0) {
+      throw new Error(`Database ${this.dbPath} is not migrated yet (${pending.join(', ')}), and is opened read-only`);
+    }
+  }
+
   /**
    * Close all database connections
    * @returns {Promise<void>}
@@ -227,7 +315,7 @@ class ValueSetDatabase {
 
     await new Promise((resolve) => {
       this._writeDb.close((err) => {
-        if (err) console.warn(`Warning closing database connection: ${err.message}`);
+        if (err) txLog().warn(`Warning closing database connection: ${err.message}`);
         this._writeDb = null;
         resolve();
       });
@@ -256,7 +344,7 @@ class ValueSetDatabase {
     await this.close();
 
     return new Promise((resolve, reject) => {
-      const db = new sqlite3.Database(this.dbPath, (err) => {
+      const db = new sqlite3.Database(this.dbPath, guarded(reject, (err) => {
         if (err) {
           reject(new Error(`Failed to create database ${this.dbPath}: ${err.message}`));
           return;
@@ -378,7 +466,7 @@ class ValueSetDatabase {
             }
           });
         });
-      });
+      }));
     });
   }
 
@@ -455,6 +543,36 @@ class ValueSetDatabase {
     });
   }
 
+  /**
+   * The most recent VSAC sync run, or null if there has never been one
+   * @returns {Promise<{id: number, status: string, started_at: number, finished_at: number|null}|null>}
+   */
+  async getLastRun() {
+    const db = await this._getReadConnection();
+    return new Promise((resolve, reject) => {
+      db.get('SELECT id, status, started_at, finished_at FROM vsac_runs ORDER BY id DESC LIMIT 1', [],
+          (err, row) => err ? reject(err) : resolve(row || null));
+    });
+  }
+
+  /**
+   * Close off runs still marked 'running'. Only one process syncs a cache, so at
+   * startup any such run was cut short when the server stopped.
+   * @returns {Promise<number>} the number of runs marked as interrupted
+   */
+  async markInterruptedRuns() {
+    const db = await this._getWriteConnection();
+    return new Promise((resolve, reject) => {
+      db.run(
+          `UPDATE vsac_runs SET finished_at = strftime('%s','now'), status = 'error',
+                                error_message = 'interrupted (server stopped during the sync)'
+           WHERE status = 'running'`,
+          [],
+          function(err) { err ? reject(err) : resolve(this.changes); }
+      );
+    });
+  }
+
   /**
    * Get a setting value from the vsac_settings table
    * @param {string} key - The setting key
@@ -463,10 +581,32 @@ class ValueSetDatabase {
   async getSetting(key) {
     const db = await this._getReadConnection();
     return new Promise((resolve, reject) => {
-      db.get('SELECT value FROM vsac_settings WHERE key = ?', [key], (err, row) => {
+      db.get('SELECT value FROM vsac_settings WHERE key = ?', [key], guarded(reject, (err, row) => {
         if (err) reject(err);
         else resolve(row ? row.value : null);
-      });
+      }));
+    });
+  }
+
+  /**
+   * The generation (see GENERATION_KEY): 0 until a sync has bumped it. One read by key.
+   * @returns {Promise<number>}
+   */
+  async getGeneration() {
+    const value = await this.getSetting(GENERATION_KEY);
+    return value === null ? 0 : Number(value);
+  }
+
+  /**
+   * Add one to the generation, in one statement.
+   * @returns {Promise<void>}
+   */
+  async bumpGeneration() {
+    const db = await this._getWriteConnection();
+    return new Promise((resolve, reject) => {
+      db.run(`INSERT INTO vsac_settings (key, value) VALUES (?, '1')
+                ON CONFLICT(key) DO UPDATE SET value = CAST(value AS INTEGER) + 1`,
+          [GENERATION_KEY], err => err ? reject(err) : resolve());
     });
   }
 
@@ -488,6 +628,18 @@ class ValueSetDatabase {
     });
   }
 
+  /**
+   * Remove a setting from the vsac_settings table
+   * @param {string} key - The setting key
+   * @returns {Promise<void>}
+   */
+  async deleteSetting(key) {
+    const db = await this._getWriteConnection();
+    return new Promise((resolve, reject) => {
+      db.run('DELETE FROM vsac_settings WHERE key = ?', [key], err => err ? reject(err) : resolve());
+    });
+  }
+
   /**
    * True if this cache was fully populated: markComplete() was reached. A cache
    * whose population was cut short (the process killed part way through) has no
@@ -514,31 +666,35 @@ class ValueSetDatabase {
   /**
    * Insert or update a single ValueSet in the database
    * @param {Object} valueSet - The ValueSet resource
-   * @param {string} [contentHash] - Optional pre-computed content hash to store
+   * @param {string} [contentHash] - Optional pre-computed content hash to store; by default the
+   *   hash of the content stored, as the backfill in _migrateIfNeeded computes it, so no row is
+   *   written without one (a row without one is backfilled by the next process to open the file)
    * @returns {Promise<void>}
    */
   async upsertValueSet(valueSet, contentHash = null) {
     if (!valueSet.url) {
       throw new Error('ValueSet must have a url property');
     }
+    const content = JSON.stringify(valueSet);
+    contentHash = contentHash || crypto.createHash('sha256').update(content).digest('hex');
 
     const db = await this._getWriteConnection();
 
     return new Promise((resolve, reject) => {
       // Step 1: Delete existing related records
-      db.run('DELETE FROM valueset_identifiers WHERE valueset_id = ?', [valueSet.id], (err) => {
+      db.run('DELETE FROM valueset_identifiers WHERE valueset_id = ?', [valueSet.id], guarded(reject, (err) => {
         if (err) {
           reject(new Error(`Failed to delete identifiers: ${err.message}`));
           return;
         }
 
-        db.run('DELETE FROM valueset_jurisdictions WHERE valueset_id = ?', [valueSet.id], (err) => {
+        db.run('DELETE FROM valueset_jurisdictions WHERE valueset_id = ?', [valueSet.id], guarded(reject, (err) => {
           if (err) {
             reject(new Error(`Failed to delete jurisdictions: ${err.message}`));
             return;
           }
 
-          db.run('DELETE FROM valueset_systems WHERE valueset_id = ?', [valueSet.id], (err) => {
+          db.run('DELETE FROM valueset_systems WHERE valueset_id = ?', [valueSet.id], guarded(reject, (err) => {
             if (err) {
               reject(new Error(`Failed to delete systems: ${err.message}`));
               return;
@@ -583,9 +739,9 @@ class ValueSetDatabase {
               valueSet.publisher || null,
               valueSet.status || null,
               valueSet.title || null,
-              JSON.stringify(valueSet),
+              content,
               contentHash
-            ], (err) => {
+            ], guarded(reject, (err) => {
               if (err) {
                 reject(new Error(`Failed to insert main record: ${err.message}`));
                 return;
@@ -593,10 +749,10 @@ class ValueSetDatabase {
 
               // Step 3: Insert related records
               this._insertRelatedRecords(db, valueSet, resolve, reject);
-            });
-          });
-        });
-      });
+            }));
+          }));
+        }));
+      }));
     });
   }
 
@@ -758,7 +914,7 @@ class ValueSetDatabase {
     const db = await this._getReadConnection();
 
     return new Promise((resolve, reject) => {
-      db.all('SELECT id, url, version, content, content_hash FROM valuesets', [], (err, rows) => {
+      db.all('SELECT id, url, version, content, content_hash FROM valuesets', [], guarded(reject, (err, rows) => {
         if (err) {
           reject(new Error(`Failed to load value sets: ${err.message}`));
           return;
@@ -769,21 +925,11 @@ class ValueSetDatabase {
           const valueSetMap = new Map();
 
           for (const row of rows) {
-            let valueSet;
-            try {
-              valueSet = new ValueSet(JSON.parse(row.content));
-            } catch (e) {
-              // one unacceptable value set (e.g. one containing a CodeSystem, which the
-              // server doesn't support) must not take the whole package's value sets with it
-              require('../../library/logger').getInstance().child({ module: 'tx' })
-                .warn(`${source || 'ValueSet database'}: skipping ValueSet ${row.url || row.id}${row.version ? '|' + row.version : ''}: ${e.message}`);
+            const valueSet = this._rowToValueSet(row, source);
+            if (!valueSet) {
               this.vsCount--;
               continue;
             }
-            valueSet.sourcePackage = source;
-            // Attach the stored content hash so callers can detect changes
-            // without recomputing over the full JSON.
-            valueSet.contentHash = row.content_hash || null;
             // Store by URL and id alone
             this.addToMap(valueSetMap, row.id, row.url, row.version, valueSet);
           }
@@ -792,10 +938,135 @@ class ValueSetDatabase {
         } catch (error) {
           reject(new Error(`Failed to parse value set content: ${error.message}`));
         }
-      });
+      }));
+    });
+  }
+
+  /**
+   * Build the ValueSet for a row (id, url, version, content, content_hash) - or null if the
+   * content isn't an acceptable value set, which is logged and then treated as absent
+   * @param {Object} row
+   * @param {string} source
+   * @returns {ValueSet|null}
+   * @private
+   */
+  _rowToValueSet(row, source) {
+    let valueSet;
+    try {
+      valueSet = new ValueSet(JSON.parse(row.content));
+    } catch (e) {
+      // one unacceptable value set (e.g. one containing a CodeSystem, which the
+      // server doesn't support) must not take the whole package's value sets with it
+      require('../../library/logger').getInstance().child({ module: 'tx' })
+        .warn(`${source || 'ValueSet database'}: skipping ValueSet ${row.url || row.id}${row.version ? '|' + row.version : ''}: ${e.message}`);
+      return null;
+    }
+    valueSet.sourcePackage = source;
+    // Attach the stored content hash so callers can detect changes
+    // without recomputing over the full JSON.
+    valueSet.contentHash = row.content_hash || null;
+    return valueSet;
+  }
+
+  /**
+   * Read one ValueSet by id, for providers that read value sets on demand instead of
+   * holding them all in memory (see loadAllValueSets)
+   * @param {string} id
+   * @param {string} source
+   * @returns {Promise<ValueSet|null>} null if there's no such row, or it was rejected
+   */
+  async loadValueSet(id, source) {
+    const db = await this._getReadConnection();
+    const row = await new Promise((resolve, reject) => {
+      db.get('SELECT id, url, version, content, content_hash FROM valuesets WHERE id = ?', [id],
+        (err, row) => err ? reject(new Error(`Failed to load value set ${id}: ${err.message}`)) : resolve(row));
+    });
+    const vs = row ? this._rowToValueSet(row, source) : null;
+    if (vs) {
+      // the size of what it was read from, for a provider that keeps some (see VSAC RecentValueSets)
+      vs.storedLength = row.content.length;
+    }
+    return vs;
+  }
+
+  /**
+   * The id and version of every row for a url (or every row, for null), in the order loadAllValueSets sees them -
+   * enough to work out which one a url (and version) refers to (see addToMap) without
+   * reading any content
+   * @param {string} url
+   * @returns {Promise<Array<{id: string, url: string, version: string}>>}
+   */
+  async listVersions(url) {
+    const db = await this._getReadConnection();
+    return new Promise((resolve, reject) => {
+      db.all(url == null ? 'SELECT id, url, version FROM valuesets ORDER BY rowid' : 'SELECT id, url, version FROM valuesets WHERE url = ? ORDER BY rowid', url == null ? [] : [url],
+        (err, rows) => err ? reject(new Error(`Failed to list versions of ${url}: ${err.message}`)) : resolve(rows));
     });
   }
 
+  /**
+   * Read several ValueSets by id
+   * @param {string[]} ids
+   * @param {string} source
+   * @returns {Promise<Map<string, ValueSet>>} id -> ValueSet, for the ids there are acceptable rows for
+   */
+  async loadValueSets(ids, source) {
+    const db = await this._getReadConnection();
+    const result = new Map();
+    for (const row of (await this._readRows(db, ids)).values()) {
+      const vs = this._rowToValueSet(row, source);
+      if (vs) {
+        result.set(row.id, vs);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * The stored content hash for url|version, or undefined if there's no such row
+   * @param {string} url
+   * @param {string} version
+   * @returns {Promise<{id: string, content_hash: string}|undefined>}
+   */
+  async getVersion(url, version) {
+    const db = await this._getReadConnection();
+    return new Promise((resolve, reject) => {
+      db.get('SELECT id, content_hash FROM valuesets WHERE url = ? AND version = ?', [url, version],
+        (err, row) => err ? reject(new Error(`Failed to read ${url}|${version}: ${err.message}`)) : resolve(row));
+    });
+  }
+
+  /**
+   * Every url|version in the database (as a Set of 'url|version' strings)
+   * @returns {Promise<Set<string>>}
+   */
+  async listVersionKeys() {
+    const db = await this._getReadConnection();
+    return new Promise((resolve, reject) => {
+      db.all('SELECT url, version FROM valuesets WHERE version IS NOT NULL', [], guarded(reject, (err, rows) => {
+        if (err) {
+          reject(new Error(`Failed to list value set versions: ${err.message}`));
+        } else {
+          resolve(new Set(rows.map(row => `${row.url}|${row.version}`)));
+        }
+      }));
+    });
+  }
+
+  /**
+   * Count the value sets (sets vsCount), and the distinct urls among them
+   * @returns {Promise<{total: number, urls: number}>}
+   */
+  async countValueSets() {
+    const db = await this._getReadConnection();
+    const row = await new Promise((resolve, reject) => {
+      db.get('SELECT COUNT(*) AS total, COUNT(DISTINCT url) AS urls FROM valuesets', [],
+        (err, row) => err ? reject(new Error(`Failed to count value sets: ${err.message}`)) : resolve(row));
+    });
+    this.vsCount = row.total;
+    return row;
+  }
+
   addToMap(valueSetMap, id, url, version, valueSet) {
     // The bare-url key must resolve to the *latest* version, but rows arrive in no
     // particular order (and several versions of the same url coexist - e.g. VSAC, where
@@ -840,17 +1111,22 @@ class ValueSetDatabase {
     const canOptimize = elements && elements.length > 0 &&
         elements.every(e => INDEXED_COLUMNS.includes(e));
 
-    // Always include 'id' in the columns to select when optimizing
-    const columnsToSelect = canOptimize
+    // Always include 'id' in the columns to select when optimizing (and the version, when the
+    // results are matched on it - see versionSearchMatches)
+    const versionAsked = searchParams.filter(p => p.name.toLowerCase() === 'version').map(p => p.value);
+    let columnsToSelect = canOptimize
         ? (elements.includes('id') ? elements : ['id', ...elements])
         : null;
+    if (columnsToSelect && versionAsked.length > 0 && !columnsToSelect.includes('version')) {
+      columnsToSelect = [...columnsToSelect, 'version'];
+    }
 
     const db = await this._getReadConnection();
 
     return new Promise((resolve, reject) => {
       const { query, params } = this._buildSearchQuery(searchParams, columnsToSelect);
 
-      db.all(query, params, (err, rows) => {
+      db.all(query, params, guarded(reject, (err, rows) => {
         if (err) {
           reject(new Error(`Search query failed: ${err.message}`));
           return;
@@ -879,12 +1155,57 @@ class ValueSetDatabase {
             // (see loadAllValueSets), so it isn't a result
             results = rows.map(row => map.get(row.id)).filter(vs => vs);
           }
+          for (const criteria of versionAsked) {
+            results = results.filter(r => {
+              const json = r.jsonObj || r;
+              return VersionUtilities.versionSearchMatches(criteria, json.version, VersionUtilities.versionAlgorithmOf(json));
+            });
+          }
 
           resolve(results);
         } catch (error) {
           reject(new Error(`Failed to parse search results: ${error.message}`));
         }
-      });
+      }));
+    });
+  }
+
+  /**
+   * The rows that match a search, in the order search() finds them, with only the indexed
+   * columns a search is sorted by - for a provider that reads the matching value sets on demand,
+   * and only reads the ones it has to return
+   * @param {Array<{name: string, value: string}>} searchParams
+   * @returns {Promise<Array<{id: string, url: string, version: string, date: string, name: string}>>}
+   */
+  async searchRows(searchParams) {
+    const db = await this._getReadConnection();
+    const { query, params } = this._buildSearchQuery(searchParams, ['id', 'url', 'version', 'date', 'name']);
+    const rows = await new Promise((resolve, reject) => {
+      db.all(query, params, (err, rows) => err ? reject(new Error(`Search query failed: ${err.message}`)) : resolve(rows));
+    });
+    // the query only narrows a version search to the versions that could match: they are matched
+    // here, as search() matches them (on the version alone: the rows have no versionAlgorithm)
+    const versionAsked = searchParams.filter(p => p.name.toLowerCase() === 'version').map(p => p.value);
+    return rows.filter(row => versionAsked.every(criteria => VersionUtilities.versionSearchMatches(criteria, row.version)));
+  }
+
+  /**
+   * Read the rows for a list of ids
+   * @param {sqlite3.Database} db
+   * @param {string[]} ids
+   * @returns {Promise<Map<string, Object>>} id -> row (id, url, version, content, content_hash)
+   * @private
+   */
+  _readRows(db, ids) {
+    return new Promise((resolve, reject) => {
+      db.all('SELECT id, url, version, content, content_hash FROM valuesets WHERE id IN (SELECT value FROM json_each(?))',
+        [JSON.stringify(ids)], guarded(reject, (err, rows) => {
+          if (err) {
+            reject(new Error(`Failed to read value sets: ${err.message}`));
+          } else {
+            resolve(new Map(rows.map(row => [row.id, row])));
+          }
+        }));
     });
   }
 
@@ -898,7 +1219,7 @@ class ValueSetDatabase {
 
     return new Promise((resolve, reject) => {
       // Get URLs to delete first
-      db.all('SELECT url FROM valuesets WHERE last_seen < ?', [cutoffTimestamp], (err, rows) => {
+      db.all('SELECT url FROM valuesets WHERE last_seen < ?', [cutoffTimestamp], guarded(reject, (err, rows) => {
         if (err) {
           reject(new Error(`Failed to find old records: ${err.message}`));
           return;
@@ -941,21 +1262,21 @@ class ValueSetDatabase {
 
         pendingDeletes = 3; // identifiers, jurisdictions, systems
 
-        db.run(`DELETE FROM valueset_identifiers WHERE valueset_id IN (${placeholders})`, idsToDelete, (err) => {
+        db.run(`DELETE FROM valueset_identifiers WHERE valueset_id IN (${placeholders})`, idsToDelete, guarded(reject, (err) => {
           if (err) deleteError(new Error(`Failed to delete identifier records: ${err.message}`));
           else deleteComplete();
-        });
+        }));
 
-        db.run(`DELETE FROM valueset_jurisdictions WHERE valueset_id IN (${placeholders})`, idsToDelete, (err) => {
+        db.run(`DELETE FROM valueset_jurisdictions WHERE valueset_id IN (${placeholders})`, idsToDelete, guarded(reject, (err) => {
           if (err) deleteError(new Error(`Failed to delete jurisdiction records: ${err.message}`));
           else deleteComplete();
-        });
+        }));
 
-        db.run(`DELETE FROM valueset_systems WHERE valueset_id IN (${placeholders})`, idsToDelete, (err) => {
+        db.run(`DELETE FROM valueset_systems WHERE valueset_id IN (${placeholders})`, idsToDelete, guarded(reject, (err) => {
           if (err) deleteError(new Error(`Failed to delete system records: ${err.message}`));
           else deleteComplete();
-        });
-      });
+        }));
+      }));
     });
   }
 
@@ -992,17 +1313,17 @@ class ValueSetDatabase {
       };
 
       // Total count
-      db.get(queries[0], [], (err, row) => {
+      db.get(queries[0], [], guarded(reject, (err, row) => {
         if (err) {
           handleError(err);
           return;
         }
         results.totalValueSets = row.total;
         checkComplete();
-      });
+      }));
 
       // Status breakdown
-      db.all(queries[1], [], (err, rows) => {
+      db.all(queries[1], [], guarded(reject, (err, rows) => {
         if (err) {
           handleError(err);
           return;
@@ -1012,17 +1333,17 @@ class ValueSetDatabase {
           results.byStatus[row.status || 'null'] = row.count;
         }
         checkComplete();
-      });
+      }));
 
       // System count
-      db.get(queries[2], [], (err, row) => {
+      db.get(queries[2], [], guarded(reject, (err, row) => {
         if (err) {
           handleError(err);
           return;
         }
         results.totalSystems = row.systems;
         checkComplete();
-      });
+      }));
     });
   }
 
@@ -1043,13 +1364,16 @@ class ValueSetDatabase {
 
       switch (name.toLowerCase()) {
         case 'url':
-          conditions.push('v.url = ?');
-          params.push(value);
+          // a left match (case-sensitive): the url starts with the value
+          conditions.push('substr(v.url, 1, length(?)) = ?');
+          params.push(value, value);
           break;
 
         case 'version':
-          conditions.push('v.version LIKE ?');
-          params.push(`%${value}%`);
+          // version-aware matching (see VersionUtilities.versionSearchMatches): narrowed here to
+          // the versions that could match, and matched on the results (see search)
+          conditions.push("v.version LIKE ? ESCAPE '\\'");
+          params.push(VersionUtilities.versionSearchPrefix(value).replace(/[\\%_]/g, c => '\\' + c) + '%');
           break;
 
         case 'name':
@@ -1149,7 +1473,7 @@ class ValueSetDatabase {
     const db = await this._getReadConnection();
 
     return new Promise((resolve, reject) => {
-      db.all('SELECT url FROM valuesets ORDER BY url', [], (err, rows) => {
+      db.all('SELECT url FROM valuesets ORDER BY url', [], guarded(reject, (err, rows) => {
         if (err) {
           reject(new Error(`Failed to list value sets: ${err.message}`));
           return;
@@ -1157,7 +1481,7 @@ class ValueSetDatabase {
 
         const urls = rows.map(row => row.url);
         resolve(urls);
-      });
+      }));
     });
   }
 }