@nymphjs/driver-sqlite3 1.0.0-beta.6 → 1.0.0-beta.61

package/src/SQLite3Driver.ts

@@ -1,17 +1,19 @@
 import SQLite3 from 'better-sqlite3';
 import {
   NymphDriver,
-  EntityConstructor,
-  EntityData,
-  EntityInterface,
-  SerializedEntityData,
+  type EntityConstructor,
+  type EntityData,
+  type EntityInterface,
+  type EntityInstanceType,
+  type SerializedEntityData,
+  type FormattedSelector,
+  type Options,
+  type Selector,
+  EntityUniqueConstraintError,
   InvalidParametersError,
   NotConfiguredError,
   QueryFailedError,
   UnableToConnectError,
-  FormattedSelector,
-  Options,
-  Selector,
   xor,
 } from '@nymphjs/nymph';
 import { makeTableSuffix } from '@nymphjs/guid';
@@ -21,32 +23,57 @@ import {
   SQLite3DriverConfigDefaults as defaults,
 } from './conf';
 
+class InternalStore {
+  public link: SQLite3.Database;
+  public linkWrite?: SQLite3.Database;
+  public connected: boolean = false;
+  public transactionsStarted = 0;
+
+  constructor(link: SQLite3.Database) {
+    this.link = link;
+  }
+}
+
 /**
  * The SQLite3 Nymph database driver.
  */
 export default class SQLite3Driver extends NymphDriver {
   public config: SQLite3DriverConfig;
   protected prefix: string;
-  protected connected: boolean = false;
   // @ts-ignore: this is assigned in connect(), which is called by the constructor.
-  protected link: SQLite3.Database;
-  protected transactionsStarted = 0;
+  protected store: InternalStore;
 
   static escape(input: string) {
     if (input.indexOf('\x00') !== -1) {
       throw new InvalidParametersError(
-        'SQLite3 identifiers (like entity ETYPE) cannot contain null characters.'
+        'SQLite3 identifiers (like entity ETYPE) cannot contain null characters.',
       );
     }
 
     return '"' + input.replace(/"/g, () => '""') + '"';
   }
 
-  constructor(config: Partial<SQLite3DriverConfig>) {
+  constructor(config: Partial<SQLite3DriverConfig>, store?: InternalStore) {
     super();
     this.config = { ...defaults, ...config };
+    if (this.config.filename === ':memory:') {
+      this.config.explicitWrite = true;
+    }
     this.prefix = this.config.prefix;
-    this.connect();
+    if (store) {
+      this.store = store;
+    } else {
+      this.connect();
+    }
+  }
+
+  /**
+   * This is used internally by Nymph. Don't call it yourself.
+   *
+   * @returns A clone of this instance.
+   */
+  public clone() {
+    return new SQLite3Driver(this.config, this.store);
   }
 
   /**
@@ -54,41 +81,107 @@ export default class SQLite3Driver extends NymphDriver {
    *
    * @returns Whether this instance is connected to a SQLite3 database.
    */
-  public async connect() {
-    const { filename, fileMustExist, timeout, readonly, verbose } = this.config;
+  public connect() {
+    if (this.store && this.store.connected) {
+      return Promise.resolve(true);
+    }
+
     // Connecting
-    if (!this.connected) {
+    this._connect(false);
+
+    return Promise.resolve(this.store.connected);
+  }
+
+  private _connect(write: boolean) {
+    const { filename, fileMustExist, timeout, explicitWrite, wal, verbose } =
+      this.config;
+
+    try {
+      const setOptions = (link: SQLite3.Database) => {
+        // Set database and connection options.
+        if (wal) {
+          link.pragma('journal_mode = WAL;');
+        }
+        link.pragma('encoding = "UTF-8";');
+        link.pragma('foreign_keys = 1;');
+        link.pragma('case_sensitive_like = 1;');
+        for (let pragma of this.config.pragmas) {
+          link.pragma(pragma);
+        }
+        // Create the preg_match and regexp functions.
+        link.function('regexp', { deterministic: true }, ((
+          pattern: string,
+          subject: string,
+        ) => (this.posixRegexMatch(pattern, subject) ? 1 : 0)) as (
+          ...params: any[]
+        ) => any);
+      };
+
+      let link: SQLite3.Database;
       try {
-        this.link = new SQLite3(filename, {
-          readonly,
+        link = new SQLite3(filename, {
+          readonly: !explicitWrite && !write,
           fileMustExist,
           timeout,
           verbose,
         });
-        this.connected = true;
-        // Set database and connection options.
-        this.link.pragma('encoding = "UTF-8";');
-        this.link.pragma('foreign_keys = 1;');
-        this.link.pragma('case_sensitive_like = 1;');
-        // Create the preg_match and regexp functions.
-        this.link.function(
-          'regexp',
-          { deterministic: true },
-          (pattern: string, subject: string) =>
-            this.posixRegexMatch(pattern, subject) ? 1 : 0
-        );
       } catch (e: any) {
-        this.connected = false;
-        if (filename === ':memory:') {
-          throw new NotConfiguredError(
-            "It seems the config hasn't been set up correctly."
-          );
+        if (
+          e.code === 'SQLITE_CANTOPEN' &&
+          !explicitWrite &&
+          !write &&
+          !this.config.fileMustExist
+        ) {
+          // This happens when the file doesn't exist and we attempt to open it
+          // readonly.
+          // First open it in write mode.
+          const writeLink = new SQLite3(filename, {
+            readonly: false,
+            fileMustExist,
+            timeout,
+            verbose,
+          });
+          setOptions(writeLink);
+          writeLink.close();
+          // Now open in readonly.
+          link = new SQLite3(filename, {
+            readonly: true,
+            fileMustExist,
+            timeout,
+            verbose,
+          });
         } else {
-          throw new UnableToConnectError('Could not connect: ' + e?.message);
+          throw e;
+        }
+      }
+
+      if (!this.store) {
+        if (write) {
+          throw new Error(
+            'Tried to open in write without opening in read first.',
+          );
         }
+        this.store = new InternalStore(link);
+      } else if (write) {
+        this.store.linkWrite = link;
+      } else {
+        this.store.link = link;
+      }
+      this.store.connected = true;
+      setOptions(link);
+    } catch (e: any) {
+      if (this.store) {
+        this.store.connected = false;
+      }
+      if (filename === ':memory:') {
+        throw new NotConfiguredError(
+          "It seems the config hasn't been set up correctly. Could not connect: " +
+            e?.message,
+        );
+      } else {
+        throw new UnableToConnectError('Could not connect: ' + e?.message);
       }
     }
-    return this.connected;
   }
 
   /**
@@ -97,16 +190,24 @@ export default class SQLite3Driver extends NymphDriver {
    * @returns Whether this instance is connected to a SQLite3 database.
    */
   public async disconnect() {
-    if (this.connected) {
-      this.link.exec('PRAGMA optimize;');
-      this.link.close();
-      this.connected = false;
+    if (this.store.connected) {
+      if (this.store.linkWrite && !this.config.explicitWrite) {
+        this.store.linkWrite.exec('PRAGMA optimize;');
+        this.store.linkWrite.close();
+        this.store.linkWrite = undefined;
+      }
+      if (this.config.explicitWrite) {
+        this.store.link.exec('PRAGMA optimize;');
+      }
+      this.store.link.close();
+      this.store.transactionsStarted = 0;
+      this.store.connected = false;
     }
-    return this.connected;
+    return this.store.connected;
   }
 
   public async inTransaction() {
-    return this.transactionsStarted > 0;
+    return this.store.transactionsStarted > 0;
   }
 
   /**
@@ -115,18 +216,7 @@ export default class SQLite3Driver extends NymphDriver {
    * @returns Whether this instance is connected to a SQLite3 database.
    */
   public isConnected() {
-    return this.connected;
-  }
-
-  /**
-   * Check if SQLite3 DB is read only and throw error if so.
-   */
-  private checkReadOnlyMode() {
-    if (this.config.readonly) {
-      throw new InvalidParametersError(
-        'Attempt to write to SQLite3 DB in read only mode.'
-      );
-    }
+    return this.store.connected;
   }
 
   /**
@@ -135,158 +225,173 @@ export default class SQLite3Driver extends NymphDriver {
    * @param etype The entity type to create a table for. If this is blank, the default tables are created.
    */
   private createTables(etype: string | null = null) {
-    this.checkReadOnlyMode();
     this.startTransaction('nymph-tablecreation');
     try {
       if (etype != null) {
         // Create the entity table.
         this.queryRun(
           `CREATE TABLE IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}entities_${etype}`
-          )} ("guid" CHARACTER(24) PRIMARY KEY, "tags" TEXT, "cdate" REAL NOT NULL, "mdate" REAL NOT NULL);`
+            `${this.prefix}entities_${etype}`,
+          )} ("guid" CHARACTER(24) PRIMARY KEY, "tags" TEXT, "cdate" REAL NOT NULL, "mdate" REAL NOT NULL);`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}entities_${etype}_id_cdate`
+            `${this.prefix}entities_${etype}_id_cdate`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}entities_${etype}`
-          )} ("cdate");`
+            `${this.prefix}entities_${etype}`,
+          )} ("cdate");`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}entities_${etype}_id_mdate`
+            `${this.prefix}entities_${etype}_id_mdate`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}entities_${etype}`
-          )} ("mdate");`
+            `${this.prefix}entities_${etype}`,
+          )} ("mdate");`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}entities_${etype}_id_tags`
+            `${this.prefix}entities_${etype}_id_tags`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}entities_${etype}`
-          )} ("tags");`
+            `${this.prefix}entities_${etype}`,
+          )} ("tags");`,
         );
         // Create the data table.
         this.queryRun(
           `CREATE TABLE IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}`
+            `${this.prefix}data_${etype}`,
           )} ("guid" CHARACTER(24) NOT NULL REFERENCES ${SQLite3Driver.escape(
-            `${this.prefix}entities_${etype}`
-          )} ("guid") ON DELETE CASCADE, "name" TEXT NOT NULL, "value" TEXT NOT NULL, PRIMARY KEY("guid", "name"));`
+            `${this.prefix}entities_${etype}`,
+          )} ("guid") ON DELETE CASCADE, "name" TEXT NOT NULL, "value" TEXT NOT NULL, PRIMARY KEY("guid", "name"));`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}_id_guid`
+            `${this.prefix}data_${etype}_id_guid`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}`
-          )} ("guid");`
+            `${this.prefix}data_${etype}`,
+          )} ("guid");`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}_id_name`
+            `${this.prefix}data_${etype}_id_name`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}`
-          )} ("name");`
+            `${this.prefix}data_${etype}`,
+          )} ("name");`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}_id_value`
+            `${this.prefix}data_${etype}_id_value`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}`
-          )} ("value");`
+            `${this.prefix}data_${etype}`,
+          )} ("value");`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}_id_guid__name_user`
+            `${this.prefix}data_${etype}_id_guid__name_user`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}`
-          )} ("guid") WHERE "name" = \'user\';`
+            `${this.prefix}data_${etype}`,
+          )} ("guid") WHERE "name" = \'user\';`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}_id_guid__name_group`
+            `${this.prefix}data_${etype}_id_guid__name_group`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}`
-          )} ("guid") WHERE "name" = \'group\';`
+            `${this.prefix}data_${etype}`,
+          )} ("guid") WHERE "name" = \'group\';`,
         );
         // Create the comparisons table.
         this.queryRun(
           `CREATE TABLE IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}comparisons_${etype}`
+            `${this.prefix}comparisons_${etype}`,
           )} ("guid" CHARACTER(24) NOT NULL REFERENCES ${SQLite3Driver.escape(
-            `${this.prefix}entities_${etype}`
-          )} ("guid") ON DELETE CASCADE, "name" TEXT NOT NULL, "truthy" INTEGER, "string" TEXT, "number" REAL, PRIMARY KEY("guid", "name"));`
+            `${this.prefix}entities_${etype}`,
+          )} ("guid") ON DELETE CASCADE, "name" TEXT NOT NULL, "truthy" INTEGER, "string" TEXT, "number" REAL, PRIMARY KEY("guid", "name"));`,
+        );
+        this.queryRun(
+          `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
+            `${this.prefix}comparisons_${etype}_id_guid`,
+          )} ON ${SQLite3Driver.escape(
+            `${this.prefix}comparisons_${etype}`,
+          )} ("guid");`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}comparisons_${etype}_id_guid`
+            `${this.prefix}comparisons_${etype}_id_name`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}comparisons_${etype}`
-          )} ("guid");`
+            `${this.prefix}comparisons_${etype}`,
+          )} ("name");`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}comparisons_${etype}_id_name`
+            `${this.prefix}comparisons_${etype}_id_name__truthy`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}comparisons_${etype}`
-          )} ("name");`
+            `${this.prefix}comparisons_${etype}`,
+          )} ("name") WHERE "truthy" = 1;`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}comparisons_${etype}_id_name__truthy`
+            `${this.prefix}comparisons_${etype}_id_string`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}comparisons_${etype}`
-          )} ("name") WHERE "truthy" = 1;`
+            `${this.prefix}comparisons_${etype}`,
+          )} ("string");`,
         );
         // Create the references table.
         this.queryRun(
           `CREATE TABLE IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}references_${etype}`
+            `${this.prefix}references_${etype}`,
           )} ("guid" CHARACTER(24) NOT NULL REFERENCES ${SQLite3Driver.escape(
-            `${this.prefix}entities_${etype}`
-          )} ("guid") ON DELETE CASCADE, "name" TEXT NOT NULL, "reference" CHARACTER(24) NOT NULL, PRIMARY KEY("guid", "name", "reference"));`
+            `${this.prefix}entities_${etype}`,
+          )} ("guid") ON DELETE CASCADE, "name" TEXT NOT NULL, "reference" CHARACTER(24) NOT NULL, PRIMARY KEY("guid", "name", "reference"));`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}references_${etype}_id_guid`
+            `${this.prefix}references_${etype}_id_guid`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}references_${etype}`
-          )} ("guid");`
+            `${this.prefix}references_${etype}`,
+          )} ("guid");`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}references_${etype}_id_name`
+            `${this.prefix}references_${etype}_id_name`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}references_${etype}`
-          )} ("name");`
+            `${this.prefix}references_${etype}`,
+          )} ("name");`,
         );
         this.queryRun(
           `CREATE INDEX IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}references_${etype}_id_reference`
+            `${this.prefix}references_${etype}_id_reference`,
           )} ON ${SQLite3Driver.escape(
-            `${this.prefix}references_${etype}`
-          )} ("reference");`
+            `${this.prefix}references_${etype}`,
+          )} ("reference");`,
+        );
+        // Create the unique strings table.
+        this.queryRun(
+          `CREATE TABLE IF NOT EXISTS ${SQLite3Driver.escape(
+            `${this.prefix}uniques_${etype}`,
+          )} ("guid" CHARACTER(24) NOT NULL REFERENCES ${SQLite3Driver.escape(
+            `${this.prefix}entities_${etype}`,
+          )} ("guid") ON DELETE CASCADE, "unique" TEXT NOT NULL UNIQUE, PRIMARY KEY("guid", "unique"));`,
         );
       } else {
         // Create the UID table.
         this.queryRun(
           `CREATE TABLE IF NOT EXISTS ${SQLite3Driver.escape(
-            `${this.prefix}uids`
-          )} ("name" TEXT PRIMARY KEY NOT NULL, "cur_uid" INTEGER NOT NULL);`
+            `${this.prefix}uids`,
+          )} ("name" TEXT PRIMARY KEY NOT NULL, "cur_uid" INTEGER NOT NULL);`,
         );
       }
-      this.commit('nymph-tablecreation');
-      return true;
     } catch (e: any) {
       this.rollback('nymph-tablecreation');
       throw e;
     }
+
+    this.commit('nymph-tablecreation');
+    return true;
   }
 
   private query<T extends () => any>(
     runQuery: T,
     query: string,
-    etypes: string[] = []
+    etypes: string[] = [],
   ): ReturnType<T> {
     try {
       return runQuery();
@@ -306,13 +411,18 @@ export default class SQLite3Driver extends NymphDriver {
         } catch (e2: any) {
           throw new QueryFailedError(
             'Query failed: ' + e2?.code + ' - ' + e2?.message,
-            query
+            query,
           );
         }
+      } else if (
+        errorCode === 'SQLITE_CONSTRAINT_UNIQUE' &&
+        errorMsg.match(/^UNIQUE constraint failed: /)
+      ) {
+        throw new EntityUniqueConstraintError(`Unique constraint violation.`);
       } else {
         throw new QueryFailedError(
           'Query failed: ' + e?.code + ' - ' + e?.message,
-          query
+          query,
         );
       }
     }
@@ -323,12 +433,15 @@ export default class SQLite3Driver extends NymphDriver {
     {
       etypes = [],
       params = {},
-    }: { etypes?: string[]; params?: { [k: string]: any } } = {}
+    }: { etypes?: string[]; params?: { [k: string]: any } } = {},
   ) {
     return this.query(
-      () => this.link.prepare(query).iterate(params),
+      () =>
+        (this.store.linkWrite || this.store.link)
+          .prepare(query)
+          .iterate(params),
       `${query} -- ${JSON.stringify(params)}`,
-      etypes
+      etypes,
     );
   }
 
@@ -337,12 +450,13 @@ export default class SQLite3Driver extends NymphDriver {
     {
       etypes = [],
       params = {},
-    }: { etypes?: string[]; params?: { [k: string]: any } } = {}
+    }: { etypes?: string[]; params?: { [k: string]: any } } = {},
   ) {
     return this.query(
-      () => this.link.prepare(query).get(params),
+      () =>
+        (this.store.linkWrite || this.store.link).prepare(query).get(params),
       `${query} -- ${JSON.stringify(params)}`,
-      etypes
+      etypes,
     );
   }
 
@@ -351,32 +465,44 @@ export default class SQLite3Driver extends NymphDriver {
     {
       etypes = [],
       params = {},
-    }: { etypes?: string[]; params?: { [k: string]: any } } = {}
+    }: { etypes?: string[]; params?: { [k: string]: any } } = {},
   ) {
     return this.query(
-      () => this.link.prepare(query).run(params),
+      () =>
+        (this.store.linkWrite || this.store.link).prepare(query).run(params),
       `${query} -- ${JSON.stringify(params)}`,
-      etypes
+      etypes,
     );
   }
 
   public async commit(name: string) {
     if (name == null || typeof name !== 'string' || name.length === 0) {
       throw new InvalidParametersError(
-        'Transaction commit attempted without a name.'
+        'Transaction commit attempted without a name.',
       );
     }
-    if (this.transactionsStarted === 0) {
+    if (this.store.transactionsStarted === 0) {
       return true;
     }
     this.queryRun(`RELEASE SAVEPOINT ${SQLite3Driver.escape(name)};`);
-    this.transactionsStarted--;
+    this.store.transactionsStarted--;
+
+    if (
+      this.store.transactionsStarted === 0 &&
+      this.store.linkWrite &&
+      !this.config.explicitWrite
+    ) {
+      this.store.linkWrite.exec('PRAGMA optimize;');
+      this.store.linkWrite.close();
+      this.store.linkWrite = undefined;
+    }
+
     return true;
   }
 
   public async deleteEntityByID(
     guid: string,
-    className?: EntityConstructor | string | null
+    className?: EntityConstructor | string | null,
   ) {
     let EntityClass: EntityConstructor;
     if (typeof className === 'string' || className == null) {
@@ -386,80 +512,93 @@ export default class SQLite3Driver extends NymphDriver {
       EntityClass = className;
     }
     const etype = EntityClass.ETYPE;
-    this.checkReadOnlyMode();
     await this.startTransaction('nymph-delete');
     try {
       this.queryRun(
         `DELETE FROM ${SQLite3Driver.escape(
-          `${this.prefix}entities_${etype}`
+          `${this.prefix}entities_${etype}`,
         )} WHERE "guid"=@guid;`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
       );
       this.queryRun(
         `DELETE FROM ${SQLite3Driver.escape(
-          `${this.prefix}data_${etype}`
+          `${this.prefix}data_${etype}`,
         )} WHERE "guid"=@guid;`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
       );
       this.queryRun(
         `DELETE FROM ${SQLite3Driver.escape(
-          `${this.prefix}comparisons_${etype}`
+          `${this.prefix}comparisons_${etype}`,
         )} WHERE "guid"=@guid;`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
       );
       this.queryRun(
         `DELETE FROM ${SQLite3Driver.escape(
-          `${this.prefix}references_${etype}`
+          `${this.prefix}references_${etype}`,
         )} WHERE "guid"=@guid;`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
+      );
+      this.queryRun(
+        `DELETE FROM ${SQLite3Driver.escape(
+          `${this.prefix}uniques_${etype}`,
+        )} WHERE "guid"=@guid;`,
+        {
+          etypes: [etype],
+          params: {
+            guid,
+          },
+        },
       );
-      await this.commit('nymph-delete');
-      // Remove any cached versions of this entity.
-      if (this.nymph.config.cache) {
-        this.cleanCache(guid);
-      }
-      return true;
     } catch (e: any) {
+      this.nymph.config.debugError('sqlite3', `Delete entity error: "${e}"`);
       await this.rollback('nymph-delete');
       throw e;
     }
+
+    await this.commit('nymph-delete');
+    // Remove any cached versions of this entity.
+    if (this.nymph.config.cache) {
+      this.cleanCache(guid);
+    }
+    return true;
   }
 
   public async deleteUID(name: string) {
     if (!name) {
       throw new InvalidParametersError('Name not given for UID');
     }
-    this.checkReadOnlyMode();
+    await this.startTransaction('nymph-delete-uid');
     this.queryRun(
       `DELETE FROM ${SQLite3Driver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} WHERE "name"=@name;`,
       {
         params: {
           name,
         },
-      }
+      },
     );
+    await this.commit('nymph-delete-uid');
     return true;
   }
 
@@ -477,10 +616,10 @@ export default class SQLite3Driver extends NymphDriver {
     writeLine('');
 
     // Export UIDs.
-    let uids = this.queryIter(
+    let uids: IterableIterator<any> = this.queryIter(
       `SELECT * FROM ${SQLite3Driver.escape(
-        `${this.prefix}uids`
-      )} ORDER BY "name";`
+        `${this.prefix}uids`,
+      )} ORDER BY "name";`,
     );
     for (const uid of uids) {
       writeLine(`<${uid.name}>[${uid.cur_uid}]`);
@@ -493,8 +632,8 @@ export default class SQLite3Driver extends NymphDriver {
     writeLine('');
 
     // Get the etypes.
-    const tables = this.queryIter(
-      "SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name;"
+    const tables: IterableIterator<any> = this.queryIter(
+      "SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name;",
     );
     const etypes = [];
     for (const table of tables) {
@@ -505,14 +644,14 @@ export default class SQLite3Driver extends NymphDriver {
 
     for (const etype of etypes) {
       // Export entities.
-      const dataIterator = this.queryIter(
+      const dataIterator: IterableIterator<any> = this.queryIter(
         `SELECT e.*, d."name" AS "dname", d."value" AS "dvalue", c."string", c."number" FROM ${SQLite3Driver.escape(
-          `${this.prefix}entities_${etype}`
+          `${this.prefix}entities_${etype}`,
         )} e LEFT JOIN ${SQLite3Driver.escape(
-          `${this.prefix}data_${etype}`
+          `${this.prefix}data_${etype}`,
         )} d USING ("guid") INNER JOIN ${SQLite3Driver.escape(
-          `${this.prefix}comparisons_${etype}`
-        )} c USING ("guid", "name") ORDER BY e."guid";`
+          `${this.prefix}comparisons_${etype}`,
+        )} c USING ("guid", "name") ORDER BY e."guid";`,
       )[Symbol.iterator]();
       let datum = dataIterator.next();
       while (!datum.done) {
@@ -564,7 +703,7 @@ export default class SQLite3Driver extends NymphDriver {
     params: { [k: string]: any } = {},
     subquery = false,
     tableSuffix = '',
-    etypes: string[] = []
+    etypes: string[] = [],
   ) {
     if (typeof options.class?.alterOptions === 'function') {
       options = options.class.alterOptions(options);
@@ -574,10 +713,11 @@ export default class SQLite3Driver extends NymphDriver {
     const cTable = `c${tableSuffix}`;
     const fTable = `f${tableSuffix}`;
     const ieTable = `ie${tableSuffix}`;
+    const sTable = `s${tableSuffix}`;
     const sort = options.sort ?? 'cdate';
     const queryParts = this.iterateSelectorsForQuery(
       formattedSelectors,
-      (key, value, typeIsOr, typeIsNot) => {
+      ({ key, value, typeIsOr, typeIsNot }) => {
         const clauseNot = key.startsWith('!');
         let curQuery = '';
         for (const curValue of value) {
@@ -1267,7 +1407,7 @@ export default class SQLite3Driver extends NymphDriver {
                 params,
                 true,
                 tableSuffix,
-                etypes
+                etypes,
               );
               if (curQuery) {
                 curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1282,7 +1422,7 @@ export default class SQLite3Driver extends NymphDriver {
             case '!qref':
               const [qrefOptions, ...qrefSelectors] = curValue[1] as [
                 Options,
-                ...FormattedSelector[]
+                ...FormattedSelector[],
               ];
               const QrefEntityClass = qrefOptions.class as EntityConstructor;
               etypes.push(QrefEntityClass.ETYPE);
@@ -1294,7 +1434,7 @@ export default class SQLite3Driver extends NymphDriver {
                 params,
                 false,
                 makeTableSuffix(),
-                etypes
+                etypes,
               );
               if (curQuery) {
                 curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1315,22 +1455,35 @@ export default class SQLite3Driver extends NymphDriver {
           }
         }
         return curQuery;
-      }
+      },
     );
 
     let sortBy: string;
+    let sortByInner: string;
+    let sortJoin = '';
+    const order = options.reverse ? ' DESC' : '';
     switch (sort) {
       case 'mdate':
-        sortBy = '"mdate"';
+        sortBy = `${eTable}."mdate"${order}`;
+        sortByInner = `${ieTable}."mdate"${order}`;
         break;
       case 'cdate':
+        sortBy = `${eTable}."cdate"${order}`;
+        sortByInner = `${ieTable}."cdate"${order}`;
+        break;
       default:
-        sortBy = '"cdate"';
+        const name = `param${++count.i}`;
+        sortJoin = `LEFT JOIN (
+            SELECT "guid", "string", "number"
+            FROM ${SQLite3Driver.escape(this.prefix + 'comparisons_' + etype)}
+            WHERE "name"=@${name}
+            ORDER BY "number"${order}, "string"${order}
+          ) ${sTable} USING ("guid")`;
+        sortBy = `${sTable}."number"${order}, ${sTable}."string"${order}`;
+        sortByInner = sortBy;
+        params[name] = sort;
         break;
     }
-    if (options.reverse) {
-      sortBy += ' DESC';
-    }
 
     let query: string;
     if (queryParts.length) {
@@ -1351,24 +1504,25 @@ export default class SQLite3Driver extends NymphDriver {
             query = `SELECT COUNT("guid") AS "count" FROM (
                 SELECT "guid"
                 FROM ${SQLite3Driver.escape(
-                  this.prefix + 'entities_' + etype
+                  this.prefix + 'entities_' + etype,
                 )} ${ieTable}
                 WHERE (${whereClause})${limit}${offset}
               )`;
           } else {
             query = `SELECT COUNT("guid") AS "count"
               FROM ${SQLite3Driver.escape(
-                this.prefix + 'entities_' + etype
+                this.prefix + 'entities_' + etype,
               )} ${ieTable}
               WHERE (${whereClause})`;
           }
         } else if (options.return === 'guid') {
           query = `SELECT "guid"
             FROM ${SQLite3Driver.escape(
-              this.prefix + 'entities_' + etype
+              this.prefix + 'entities_' + etype,
             )} ${ieTable}
+            ${sortJoin}
             WHERE (${whereClause})
-            ORDER BY ${ieTable}.${sortBy}${limit}${offset}`;
+            ORDER BY ${sortByInner}, "guid"${limit}${offset}`;
         } else {
           query = `SELECT
               ${eTable}."guid",
@@ -1380,23 +1534,25 @@ export default class SQLite3Driver extends NymphDriver {
               ${cTable}."string",
               ${cTable}."number"
             FROM ${SQLite3Driver.escape(
-              this.prefix + 'entities_' + etype
+              this.prefix + 'entities_' + etype,
             )} ${eTable}
             LEFT JOIN ${SQLite3Driver.escape(
-              this.prefix + 'data_' + etype
+              this.prefix + 'data_' + etype,
             )} ${dTable} USING ("guid")
             INNER JOIN ${SQLite3Driver.escape(
-              this.prefix + 'comparisons_' + etype
+              this.prefix + 'comparisons_' + etype,
             )} ${cTable} USING ("guid", "name")
+            ${sortJoin}
             INNER JOIN (
               SELECT "guid"
               FROM ${SQLite3Driver.escape(
-                this.prefix + 'entities_' + etype
+                this.prefix + 'entities_' + etype,
               )} ${ieTable}
+              ${sortJoin}
               WHERE (${whereClause})
-              ORDER BY ${ieTable}.${sortBy}${limit}${offset}
+              ORDER BY ${sortByInner}${limit}${offset}
             ) ${fTable} USING ("guid")
-            ORDER BY ${eTable}.${sortBy}`;
+            ORDER BY ${sortBy}, ${eTable}."guid"`;
         }
       }
     } else {
@@ -1416,21 +1572,22 @@ export default class SQLite3Driver extends NymphDriver {
             query = `SELECT COUNT("guid") AS "count" FROM (
                 SELECT "guid"
                 FROM ${SQLite3Driver.escape(
-                  this.prefix + 'entities_' + etype
+                  this.prefix + 'entities_' + etype,
                 )} ${ieTable}${limit}${offset}
               )`;
           } else {
             query = `SELECT COUNT("guid") AS "count"
               FROM ${SQLite3Driver.escape(
-                this.prefix + 'entities_' + etype
+                this.prefix + 'entities_' + etype,
               )} ${ieTable}`;
           }
         } else if (options.return === 'guid') {
           query = `SELECT "guid"
             FROM ${SQLite3Driver.escape(
-              this.prefix + 'entities_' + etype
+              this.prefix + 'entities_' + etype,
             )} ${ieTable}
-            ORDER BY ${ieTable}.${sortBy}${limit}${offset}`;
+            ${sortJoin}
+            ORDER BY ${sortByInner}, "guid"${limit}${offset}`;
         } else {
           if (limit || offset) {
             query = `SELECT
@@ -1443,22 +1600,24 @@ export default class SQLite3Driver extends NymphDriver {
                 ${cTable}."string",
                 ${cTable}."number"
               FROM ${SQLite3Driver.escape(
-                this.prefix + 'entities_' + etype
+                this.prefix + 'entities_' + etype,
               )} ${eTable}
               LEFT JOIN ${SQLite3Driver.escape(
-                this.prefix + 'data_' + etype
+                this.prefix + 'data_' + etype,
               )} ${dTable} USING ("guid")
               INNER JOIN ${SQLite3Driver.escape(
-                this.prefix + 'comparisons_' + etype
+                this.prefix + 'comparisons_' + etype,
               )} c USING ("guid", "name")
+              ${sortJoin}
               INNER JOIN (
                 SELECT "guid"
                 FROM ${SQLite3Driver.escape(
-                  this.prefix + 'entities_' + etype
+                  this.prefix + 'entities_' + etype,
                 )} ${ieTable}
-                ORDER BY ${ieTable}.${sortBy}${limit}${offset}
+                ${sortJoin}
+                ORDER BY ${sortByInner}${limit}${offset}
               ) ${fTable} USING ("guid")
-              ORDER BY ${eTable}.${sortBy}`;
+              ORDER BY ${sortBy}, ${eTable}."guid"`;
           } else {
             query = `SELECT
                 ${eTable}."guid",
@@ -1470,15 +1629,16 @@ export default class SQLite3Driver extends NymphDriver {
                 ${cTable}."string",
                 ${cTable}."number"
               FROM ${SQLite3Driver.escape(
-                this.prefix + 'entities_' + etype
+                this.prefix + 'entities_' + etype,
               )} ${eTable}
               LEFT JOIN ${SQLite3Driver.escape(
-                this.prefix + 'data_' + etype
+                this.prefix + 'data_' + etype,
               )} ${dTable} USING ("guid")
               INNER JOIN ${SQLite3Driver.escape(
-                this.prefix + 'comparisons_' + etype
+                this.prefix + 'comparisons_' + etype,
               )} ${cTable} USING ("guid", "name")
-              ORDER BY ${eTable}.${sortBy}`;
+              ${sortJoin}
+              ORDER BY ${sortBy}, ${eTable}."guid"`;
           }
         }
       }
@@ -1498,14 +1658,14 @@ export default class SQLite3Driver extends NymphDriver {
   protected performQuery(
     options: Options,
     formattedSelectors: FormattedSelector[],
-    etype: string
+    etype: string,
   ): {
     result: any;
   } {
     const { query, params, etypes } = this.makeEntityQuery(
       options,
       formattedSelectors,
-      etype
+      etype,
     );
     const result = this.queryIter(query, { etypes, params })[Symbol.iterator]();
     return {
@@ -1524,35 +1684,16 @@ export default class SQLite3Driver extends NymphDriver {
   public async getEntities<T extends EntityConstructor = EntityConstructor>(
     options?: Options<T>,
     ...selectors: Selector[]
-  ): Promise<ReturnType<T['factorySync']>[]>;
+  ): Promise<EntityInstanceType<T>[]>;
   public async getEntities<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> = {},
     ...selectors: Selector[]
-  ): Promise<ReturnType<T['factorySync']>[] | string[] | number> {
-    return this.getEntitiesSync(options, ...selectors);
-  }
-
-  protected getEntitiesSync<T extends EntityConstructor = EntityConstructor>(
-    options: Options<T> & { return: 'count' },
-    ...selectors: Selector[]
-  ): number;
-  protected getEntitiesSync<T extends EntityConstructor = EntityConstructor>(
-    options: Options<T> & { return: 'guid' },
-    ...selectors: Selector[]
-  ): string[];
-  protected getEntitiesSync<T extends EntityConstructor = EntityConstructor>(
-    options?: Options<T>,
-    ...selectors: Selector[]
-  ): ReturnType<T['factorySync']>[];
-  protected getEntitiesSync<T extends EntityConstructor = EntityConstructor>(
-    options: Options<T> = {},
-    ...selectors: Selector[]
-  ): ReturnType<T['factorySync']>[] | string[] | number {
-    const { result, process } = this.getEntitesRowLike<T>(
+  ): Promise<EntityInstanceType<T>[] | string[] | number> {
+    const { result, process } = this.getEntitiesRowLike<T>(
       options,
       selectors,
-      (options, formattedSelectors, etype) =>
-        this.performQuery(options, formattedSelectors, etype),
+      ({ options, selectors, etype }) =>
+        this.performQuery(options, selectors, etype),
       () => {
         const next: any = result.next();
         return next.done ? null : next.value;
@@ -1573,7 +1714,7 @@ export default class SQLite3Driver extends NymphDriver {
             : row.value === 'S'
             ? JSON.stringify(row.string)
             : row.value,
-      })
+      }),
     );
     const value = process();
     if (value instanceof Error) {
@@ -1586,175 +1727,243 @@ export default class SQLite3Driver extends NymphDriver {
     if (name == null) {
       throw new InvalidParametersError('Name not given for UID.');
     }
-    const result = this.queryGet(
+    const result: any = this.queryGet(
       `SELECT "cur_uid" FROM ${SQLite3Driver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} WHERE "name"=@name;`,
       {
         params: {
           name: name,
         },
-      }
+      },
     );
     return (result?.cur_uid as number | null) ?? null;
   }
 
-  public async import(filename: string) {
-    this.checkReadOnlyMode();
+  public async import(filename: string, transaction?: boolean) {
     try {
       return this.importFromFile(
         filename,
         async (guid, tags, sdata, etype) => {
-          this.queryRun(
-            `DELETE FROM ${SQLite3Driver.escape(
-              `${this.prefix}entities_${etype}`
-            )} WHERE "guid"=@guid;`,
-            {
-              etypes: [etype],
-              params: {
-                guid,
-              },
-            }
-          );
-          this.queryRun(
-            `DELETE FROM ${SQLite3Driver.escape(
-              `${this.prefix}data_${etype}`
-            )} WHERE "guid"=@guid;`,
-            {
-              etypes: [etype],
-              params: {
-                guid,
+          try {
+            await this.startTransaction(`nymph-import-entity-${guid}`);
+
+            const cdate = Number(JSON.parse(sdata.cdate));
+            delete sdata.cdate;
+            const mdate = Number(JSON.parse(sdata.mdate));
+            delete sdata.mdate;
+
+            this.queryRun(
+              `DELETE FROM ${SQLite3Driver.escape(
+                `${this.prefix}entities_${etype}`,
+              )} WHERE "guid"=@guid;`,
+              {
+                etypes: [etype],
+                params: {
+                  guid,
+                },
               },
-            }
-          );
-          this.queryRun(
-            `DELETE FROM ${SQLite3Driver.escape(
-              `${this.prefix}comparisons_${etype}`
-            )} WHERE "guid"=@guid;`,
-            {
-              etypes: [etype],
-              params: {
-                guid,
+            );
+            this.queryRun(
+              `DELETE FROM ${SQLite3Driver.escape(
+                `${this.prefix}data_${etype}`,
+              )} WHERE "guid"=@guid;`,
+              {
+                etypes: [etype],
+                params: {
+                  guid,
+                },
               },
-            }
-          );
-          this.queryRun(
-            `DELETE FROM ${SQLite3Driver.escape(
-              `${this.prefix}references_${etype}`
-            )} WHERE "guid"=@guid;`,
-            {
-              etypes: [etype],
-              params: {
-                guid,
+            );
+            this.queryRun(
+              `DELETE FROM ${SQLite3Driver.escape(
+                `${this.prefix}comparisons_${etype}`,
+              )} WHERE "guid"=@guid;`,
+              {
+                etypes: [etype],
+                params: {
+                  guid,
+                },
               },
-            }
-          );
-          this.queryRun(
-            `INSERT INTO ${SQLite3Driver.escape(
-              `${this.prefix}entities_${etype}`
-            )} ("guid", "tags", "cdate", "mdate") VALUES (@guid, @tags, @cdate, @mdate);`,
-            {
-              etypes: [etype],
-              params: {
-                guid,
-                tags: ',' + tags.join(',') + ',',
-                cdate: Number(JSON.parse(sdata.cdate)),
-                mdate: Number(JSON.parse(sdata.mdate)),
+            );
+            this.queryRun(
+              `DELETE FROM ${SQLite3Driver.escape(
+                `${this.prefix}references_${etype}`,
+              )} WHERE "guid"=@guid;`,
+              {
+                etypes: [etype],
+                params: {
+                  guid,
+                },
               },
-            }
-          );
-          delete sdata.cdate;
-          delete sdata.mdate;
-          for (const name in sdata) {
-            const value = sdata[name];
-            const uvalue = JSON.parse(value);
-            if (value === undefined) {
-              continue;
-            }
-            const storageValue =
-              typeof uvalue === 'number'
-                ? 'N'
-                : typeof uvalue === 'string'
-                ? 'S'
-                : value;
+            );
             this.queryRun(
-              `INSERT INTO ${SQLite3Driver.escape(
-                `${this.prefix}data_${etype}`
-              )} ("guid", "name", "value") VALUES (@guid, @name, @storageValue);`,
+              `DELETE FROM ${SQLite3Driver.escape(
+                `${this.prefix}uniques_${etype}`,
+              )} WHERE "guid"=@guid;`,
               {
                 etypes: [etype],
                 params: {
                   guid,
-                  name,
-                  storageValue,
                 },
-              }
+              },
             );
+
             this.queryRun(
               `INSERT INTO ${SQLite3Driver.escape(
-                `${this.prefix}comparisons_${etype}`
-              )} ("guid", "name", "truthy", "string", "number") VALUES (@guid, @name, @truthy, @string, @number);`,
+                `${this.prefix}entities_${etype}`,
+              )} ("guid", "tags", "cdate", "mdate") VALUES (@guid, @tags, @cdate, @mdate);`,
               {
                 etypes: [etype],
                 params: {
                   guid,
-                  name,
-                  truthy: uvalue ? 1 : 0,
-                  string: `${uvalue}`,
-                  number: Number(uvalue),
+                  tags: ',' + tags.join(',') + ',',
+                  cdate,
+                  mdate,
                 },
-              }
+              },
             );
-            const references = this.findReferences(value);
-            for (const reference of references) {
+            for (const name in sdata) {
+              const value = sdata[name];
+              const uvalue = JSON.parse(value);
+              if (value === undefined) {
+                continue;
+              }
+              const storageValue =
+                typeof uvalue === 'number'
+                  ? 'N'
+                  : typeof uvalue === 'string'
+                  ? 'S'
+                  : value;
               this.queryRun(
                 `INSERT INTO ${SQLite3Driver.escape(
-                  `${this.prefix}references_${etype}`
-                )} ("guid", "name", "reference") VALUES (@guid, @name, @reference);`,
+                  `${this.prefix}data_${etype}`,
+                )} ("guid", "name", "value") VALUES (@guid, @name, @storageValue);`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                     name,
-                    reference,
+                    storageValue,
                   },
-                }
+                },
+              );
+              this.queryRun(
+                `INSERT INTO ${SQLite3Driver.escape(
+                  `${this.prefix}comparisons_${etype}`,
+                )} ("guid", "name", "truthy", "string", "number") VALUES (@guid, @name, @truthy, @string, @number);`,
+                {
+                  etypes: [etype],
+                  params: {
+                    guid,
+                    name,
+                    truthy: uvalue ? 1 : 0,
+                    string: `${uvalue}`,
+                    number: Number(uvalue),
+                  },
+                },
               );
+              const references = this.findReferences(value);
+              for (const reference of references) {
+                this.queryRun(
+                  `INSERT INTO ${SQLite3Driver.escape(
+                    `${this.prefix}references_${etype}`,
+                  )} ("guid", "name", "reference") VALUES (@guid, @name, @reference);`,
+                  {
+                    etypes: [etype],
+                    params: {
+                      guid,
+                      name,
+                      reference,
+                    },
+                  },
+                );
+              }
             }
+            const uniques = await this.nymph
+              .getEntityClassByEtype(etype)
+              .getUniques({ guid, cdate, mdate, tags, data: {}, sdata });
+            for (const unique of uniques) {
+              try {
+                this.queryRun(
+                  `INSERT INTO ${SQLite3Driver.escape(
+                    `${this.prefix}uniques_${etype}`,
+                  )} ("guid", "unique") VALUES (@guid, @unique);`,
+                  {
+                    etypes: [etype],
+                    params: {
+                      guid,
+                      unique,
+                    },
+                  },
+                );
+              } catch (e: any) {
+                if (e instanceof EntityUniqueConstraintError) {
+                  this.nymph.config.debugError(
+                    'sqlite3',
+                    `Import entity unique constraint violation for GUID "${guid}" on etype "${etype}": "${unique}"`,
+                  );
+                }
+                throw e;
+              }
+            }
+            await this.commit(`nymph-import-entity-${guid}`);
+          } catch (e: any) {
+            this.nymph.config.debugError(
+              'sqlite3',
+              `Import entity error: "${e}"`,
+            );
+            await this.rollback(`nymph-import-entity-${guid}`);
+            throw e;
           }
         },
         async (name, curUid) => {
-          this.queryRun(
-            `DELETE FROM ${SQLite3Driver.escape(
-              `${this.prefix}uids`
-            )} WHERE "name"=@name;`,
-            {
-              params: {
-                name,
+          try {
+            await this.startTransaction(`nymph-import-uid-${name}`);
+            this.queryRun(
+              `DELETE FROM ${SQLite3Driver.escape(
+                `${this.prefix}uids`,
+              )} WHERE "name"=@name;`,
+              {
+                params: {
+                  name,
+                },
               },
-            }
-          );
-          this.queryRun(
-            `INSERT INTO ${SQLite3Driver.escape(
-              `${this.prefix}uids`
-            )} ("name", "cur_uid") VALUES (@name, @curUid);`,
-            {
-              params: {
-                name,
-                curUid,
+            );
+            this.queryRun(
+              `INSERT INTO ${SQLite3Driver.escape(
+                `${this.prefix}uids`,
+              )} ("name", "cur_uid") VALUES (@name, @curUid);`,
+              {
+                params: {
+                  name,
+                  curUid,
+                },
               },
-            }
-          );
+            );
+            await this.commit(`nymph-import-uid-${name}`);
+          } catch (e: any) {
+            this.nymph.config.debugError('sqlite3', `Import UID error: "${e}"`);
+            await this.rollback(`nymph-import-uid-${name}`);
+            throw e;
+          }
         },
         async () => {
-          await this.startTransaction('nymph-import');
+          if (transaction) {
+            await this.startTransaction('nymph-import');
+          }
         },
         async () => {
-          await this.commit('nymph-import');
-        }
+          if (transaction) {
+            await this.commit('nymph-import');
+          }
+        },
       );
     } catch (e: any) {
-      await this.rollback('nymph-import');
+      this.nymph.config.debugError('sqlite3', `Import error: "${e}"`);
+      if (transaction) {
+        await this.rollback('nymph-import');
+      }
       throw e;
     }
   }
@@ -1763,95 +1972,111 @@ export default class SQLite3Driver extends NymphDriver {
     if (name == null) {
       throw new InvalidParametersError('Name not given for UID.');
     }
-    this.checkReadOnlyMode();
     await this.startTransaction('nymph-newuid');
+    let curUid: number | undefined = undefined;
     try {
-      let curUid =
-        this.queryGet(
-          `SELECT "cur_uid" FROM ${SQLite3Driver.escape(
-            `${this.prefix}uids`
-          )} WHERE "name"=@name;`,
-          {
-            params: {
-              name,
+      curUid =
+        (
+          this.queryGet(
+            `SELECT "cur_uid" FROM ${SQLite3Driver.escape(
+              `${this.prefix}uids`,
+            )} WHERE "name"=@name;`,
+            {
+              params: {
+                name,
+              },
             },
-          }
+          ) as any
         )?.cur_uid ?? null;
       if (curUid == null) {
         curUid = 1;
         this.queryRun(
           `INSERT INTO ${SQLite3Driver.escape(
-            `${this.prefix}uids`
+            `${this.prefix}uids`,
           )} ("name", "cur_uid") VALUES (@name, @curUid);`,
           {
             params: {
               name,
               curUid,
             },
-          }
+          },
         );
       } else {
         curUid++;
         this.queryRun(
           `UPDATE ${SQLite3Driver.escape(
-            `${this.prefix}uids`
+            `${this.prefix}uids`,
           )} SET "cur_uid"=@curUid WHERE "name"=@name;`,
           {
             params: {
               curUid,
               name,
             },
-          }
+          },
         );
       }
-      await this.commit('nymph-newuid');
-      return curUid as number;
     } catch (e: any) {
+      this.nymph.config.debugError('sqlite3', `New UID error: "${e}"`);
       await this.rollback('nymph-newuid');
       throw e;
     }
+
+    await this.commit('nymph-newuid');
+    return curUid as number;
   }
 
   public async renameUID(oldName: string, newName: string) {
     if (oldName == null || newName == null) {
       throw new InvalidParametersError('Name not given for UID.');
     }
-    this.checkReadOnlyMode();
+    await this.startTransaction('nymph-rename-uid');
     this.queryRun(
       `UPDATE ${SQLite3Driver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} SET "name"=@newName WHERE "name"=@oldName;`,
       {
         params: {
           newName,
           oldName,
         },
-      }
+      },
     );
+    await this.commit('nymph-rename-uid');
     return true;
   }
 
   public async rollback(name: string) {
     if (name == null || typeof name !== 'string' || name.length === 0) {
       throw new InvalidParametersError(
-        'Transaction rollback attempted without a name.'
+        'Transaction rollback attempted without a name.',
       );
     }
-    if (this.transactionsStarted === 0) {
+    if (this.store.transactionsStarted === 0) {
       return true;
     }
     this.queryRun(`ROLLBACK TO SAVEPOINT ${SQLite3Driver.escape(name)};`);
-    this.transactionsStarted--;
+    this.store.transactionsStarted--;
+
+    if (
+      this.store.transactionsStarted === 0 &&
+      this.store.linkWrite &&
+      !this.config.explicitWrite
+    ) {
+      this.store.linkWrite.exec('PRAGMA optimize;');
+      this.store.linkWrite.close();
+      this.store.linkWrite = undefined;
+    }
+
     return true;
   }
 
   public async saveEntity(entity: EntityInterface) {
-    this.checkReadOnlyMode();
     const insertData = (
       guid: string,
       data: EntityData,
       sdata: SerializedEntityData,
-      etype: string
+      uniques: string[],
+      etype: string,
     ) => {
       const runInsertQuery = (name: string, value: any, svalue: string) => {
         if (value === undefined) {
@@ -1865,7 +2090,7 @@ export default class SQLite3Driver extends NymphDriver {
             : svalue;
         this.queryRun(
           `INSERT INTO ${SQLite3Driver.escape(
-            `${this.prefix}data_${etype}`
+            `${this.prefix}data_${etype}`,
           )} ("guid", "name", "value") VALUES (@guid, @name, @storageValue);`,
           {
             etypes: [etype],
@@ -1874,11 +2099,11 @@ export default class SQLite3Driver extends NymphDriver {
               name,
               storageValue,
             },
-          }
+          },
         );
         this.queryRun(
           `INSERT INTO ${SQLite3Driver.escape(
-            `${this.prefix}comparisons_${etype}`
+            `${this.prefix}comparisons_${etype}`,
           )} ("guid", "name", "truthy", "string", "number") VALUES (@guid, @name, @truthy, @string, @number);`,
           {
             etypes: [etype],
@@ -1889,13 +2114,13 @@ export default class SQLite3Driver extends NymphDriver {
               string: `${value}`,
               number: Number(value),
             },
-          }
+          },
         );
         const references = this.findReferences(svalue);
         for (const reference of references) {
           this.queryRun(
             `INSERT INTO ${SQLite3Driver.escape(
-              `${this.prefix}references_${etype}`
+              `${this.prefix}references_${etype}`,
             )} ("guid", "name", "reference") VALUES (@guid, @name, @reference);`,
             {
               etypes: [etype],
@@ -1904,10 +2129,34 @@ export default class SQLite3Driver extends NymphDriver {
                 name,
                 reference,
               },
-            }
+            },
           );
         }
       };
+      for (const unique of uniques) {
+        try {
+          this.queryRun(
+            `INSERT INTO ${SQLite3Driver.escape(
+              `${this.prefix}uniques_${etype}`,
+            )} ("guid", "unique") VALUES (@guid, @unique);`,
+            {
+              etypes: [etype],
+              params: {
+                guid,
+                unique,
+              },
+            },
+          );
+        } catch (e: any) {
+          if (e instanceof EntityUniqueConstraintError) {
+            this.nymph.config.debugError(
+              'sqlite3',
+              `Save entity unique constraint violation for GUID "${guid}" on etype "${etype}": "${unique}"`,
+            );
+          }
+          throw e;
+        }
+      }
       for (const name in data) {
         runInsertQuery(name, data[name], JSON.stringify(data[name]));
       }
@@ -1915,13 +2164,20 @@ export default class SQLite3Driver extends NymphDriver {
         runInsertQuery(name, JSON.parse(sdata[name]), sdata[name]);
       }
     };
+    let inTransaction = false;
     try {
       return this.saveEntityRowLike(
         entity,
-        async (_entity, guid, tags, data, sdata, cdate, etype) => {
+        async ({ guid, tags, data, sdata, uniques, cdate, etype }) => {
+          if (
+            Object.keys(data).length === 0 &&
+            Object.keys(sdata).length === 0
+          ) {
+            return false;
+          }
           this.queryRun(
             `INSERT INTO ${SQLite3Driver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} ("guid", "tags", "cdate", "mdate") VALUES (@guid, @tags, @cdate, @cdate);`,
             {
               etypes: [etype],
@@ -1930,15 +2186,21 @@ export default class SQLite3Driver extends NymphDriver {
                 tags: ',' + tags.join(',') + ',',
                 cdate,
               },
-            }
+            },
           );
-          insertData(guid, data, sdata, etype);
+          insertData(guid, data, sdata, uniques, etype);
           return true;
         },
-        async (entity, guid, tags, data, sdata, mdate, etype) => {
+        async ({ entity, guid, tags, data, sdata, uniques, mdate, etype }) => {
+          if (
+            Object.keys(data).length === 0 &&
+            Object.keys(sdata).length === 0
+          ) {
+            return false;
+          }
           const info = this.queryRun(
             `UPDATE ${SQLite3Driver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} SET "tags"=@tags, "mdate"=@mdate WHERE "guid"=@guid AND "mdate" <= @emdate;`,
             {
               etypes: [etype],
@@ -1948,62 +2210,80 @@ export default class SQLite3Driver extends NymphDriver {
                 guid,
                 emdate: Number(entity.mdate),
               },
-            }
+            },
           );
           let success = false;
           if (info.changes === 1) {
             this.queryRun(
               `DELETE FROM ${SQLite3Driver.escape(
-                `${this.prefix}data_${etype}`
+                `${this.prefix}data_${etype}`,
               )} WHERE "guid"=@guid;`,
               {
                 etypes: [etype],
                 params: {
                   guid,
                 },
-              }
+              },
             );
             this.queryRun(
               `DELETE FROM ${SQLite3Driver.escape(
-                `${this.prefix}comparisons_${etype}`
+                `${this.prefix}comparisons_${etype}`,
               )} WHERE "guid"=@guid;`,
               {
                 etypes: [etype],
                 params: {
                   guid,
                 },
-              }
+              },
             );
             this.queryRun(
               `DELETE FROM ${SQLite3Driver.escape(
-                `${this.prefix}references_${etype}`
+                `${this.prefix}references_${etype}`,
               )} WHERE "guid"=@guid;`,
               {
                 etypes: [etype],
                 params: {
                   guid,
                 },
-              }
+              },
             );
-            insertData(guid, data, sdata, etype);
+            this.queryRun(
+              `DELETE FROM ${SQLite3Driver.escape(
+                `${this.prefix}uniques_${etype}`,
+              )} WHERE "guid"=@guid;`,
+              {
+                etypes: [etype],
+                params: {
+                  guid,
+                },
+              },
+            );
+            insertData(guid, data, sdata, uniques, etype);
             success = true;
           }
           return success;
         },
         async () => {
           await this.startTransaction('nymph-save');
+          inTransaction = true;
         },
         async (success) => {
-          if (success) {
-            await this.commit('nymph-save');
-          } else {
-            await this.rollback('nymph-save');
+          if (inTransaction) {
+            inTransaction = false;
+            if (success) {
+              await this.commit('nymph-save');
+            } else {
+              await this.rollback('nymph-save');
+            }
           }
           return success;
-        }
+        },
       );
     } catch (e: any) {
-      await this.rollback('nymph-save');
+      this.nymph.config.debugError('sqlite3', `Save entity error: "${e}"`);
+      if (inTransaction) {
+        await this.rollback('nymph-save');
+      }
       throw e;
     }
   }
@@ -2012,39 +2292,43 @@ export default class SQLite3Driver extends NymphDriver {
     if (name == null) {
       throw new InvalidParametersError('Name not given for UID.');
     }
-    this.checkReadOnlyMode();
+    await this.startTransaction('nymph-set-uid');
     this.queryRun(
       `DELETE FROM ${SQLite3Driver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} WHERE "name"=@name;`,
       {
         params: {
           name,
         },
-      }
+      },
     );
     this.queryRun(
       `INSERT INTO ${SQLite3Driver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} ("name", "cur_uid") VALUES (@name, @curUid);`,
       {
         params: {
           name,
           curUid,
         },
-      }
+      },
     );
+    await this.commit('nymph-set-uid');
     return true;
   }
 
   public async startTransaction(name: string) {
     if (name == null || typeof name !== 'string' || name.length === 0) {
       throw new InvalidParametersError(
-        'Transaction start attempted without a name.'
+        'Transaction start attempted without a name.',
       );
     }
+    if (!this.config.explicitWrite && !this.store.linkWrite) {
+      this._connect(true);
+    }
     this.queryRun(`SAVEPOINT ${SQLite3Driver.escape(name)};`);
-    this.transactionsStarted++;
+    this.store.transactionsStarted++;
     return this.nymph;
   }
 }