@nymphjs/driver-postgresql 1.0.0-beta.9 → 1.0.0-beta.91

package/src/PostgreSQLDriver.ts

@@ -1,19 +1,22 @@
-import cp from 'child_process';
-import { Pool, PoolClient, PoolConfig, QueryResult } from 'pg';
+import pg from 'pg';
+import type { Pool, PoolClient, PoolConfig, QueryResult } from 'pg';
 import format from 'pg-format';
+import Cursor from 'pg-cursor';
 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,7 +24,7 @@ import { makeTableSuffix } from '@nymphjs/guid';
 import {
   PostgreSQLDriverConfig,
   PostgreSQLDriverConfigDefaults as defaults,
-} from './conf';
+} from './conf/index.js';
 
 type PostgreSQLDriverConnection = {
   client: PoolClient;
@@ -53,10 +56,44 @@ export default class PostgreSQLDriver extends NymphDriver {
     return format.literal(input);
   }
 
+  static escapeNullSequences(input: string) {
+    // Postgres doesn't support null bytes in `text`, and it converts strings
+    // in JSON to `text`, so we need to escape the escape sequences for null
+    // bytes.
+    return (
+      input
+        .replace(/\uFFFD/g, () => '\uFFFD\uFFFD')
+        // n so that if there's already an escape, it turns into \n
+        // - so that it won't match a \uFFFD that got turned into \uFFFD\uFFFD
+        .replace(/\\u0000/g, () => 'nu\uFFFD-')
+        .replace(/\\x00/g, () => 'nx\uFFFD-')
+    );
+  }
+
+  static unescapeNullSequences(input: string) {
+    return input
+      .replace(/nu\uFFFD-/g, () => '\\u0000')
+      .replace(/nx\uFFFD-/g, () => '\\x00')
+      .replace(/\uFFFD\uFFFD/g, () => '\uFFFD');
+  }
+
+  static escapeNulls(input: string) {
+    // Postgres doesn't support null bytes in `text`.
+    return input
+      .replace(/\uFFFD/g, () => '\uFFFD\uFFFD')
+      .replace(/\x00/g, () => '-\uFFFD-');
+  }
+
+  static unescapeNulls(input: string) {
+    return input
+      .replace(/-\uFFFD-/g, () => '\x00')
+      .replace(/\uFFFD\uFFFD/g, () => '\uFFFD');
+  }
+
   constructor(
     config: Partial<PostgreSQLDriverConfig>,
     link?: Pool,
-    transaction?: PostgreSQLDriverTransaction
+    transaction?: PostgreSQLDriverTransaction,
   ) {
     super();
     this.config = { ...defaults, ...config };
@@ -91,18 +128,28 @@ export default class PostgreSQLDriver extends NymphDriver {
     return new PostgreSQLDriver(
       this.config,
       this.link,
-      this.transaction ?? undefined
+      this.transaction ?? undefined,
     );
   }
 
-  private getConnection(): Promise<PostgreSQLDriverConnection> {
-    if (this.transaction != null && this.transaction.connection != null) {
+  private getConnection(
+    outsideTransaction = false,
+  ): Promise<PostgreSQLDriverConnection> {
+    if (
+      this.transaction != null &&
+      this.transaction.connection != null &&
+      !outsideTransaction
+    ) {
       return Promise.resolve(this.transaction.connection);
     }
     return new Promise((resolve, reject) =>
       this.link.connect((err, client, done) =>
-        err ? reject(err) : resolve({ client, done })
-      )
+        err
+          ? reject(err)
+          : client
+            ? resolve({ client, done })
+            : reject('No client returned from connect.'),
+      ),
     );
   }
 
@@ -118,8 +165,12 @@ export default class PostgreSQLDriver extends NymphDriver {
         const connection: PostgreSQLDriverConnection = await new Promise(
           (resolve, reject) =>
             this.link.connect((err, client, done) =>
-              err ? reject(err) : resolve({ client, done })
-            )
+              err
+                ? reject(err)
+                : client
+                  ? resolve({ client, done })
+                  : reject('No client returned from connect.'),
+            ),
         );
         await new Promise((resolve, reject) =>
           connection.client.query('SELECT 1;', [], (err, res) => {
@@ -127,7 +178,7 @@ export default class PostgreSQLDriver extends NymphDriver {
               reject(err);
             }
             resolve(0);
-          })
+          }),
         );
         connection.done();
       }
@@ -138,7 +189,7 @@ export default class PostgreSQLDriver extends NymphDriver {
     // Connecting, selecting database
     if (!this.connected) {
       try {
-        this.link = new Pool(this.postgresqlConfig);
+        this.link = new pg.Pool(this.postgresqlConfig);
         this.connected = true;
       } catch (e: any) {
         if (
@@ -148,7 +199,7 @@ export default class PostgreSQLDriver extends NymphDriver {
           this.postgresqlConfig.database === 'nymph'
         ) {
           throw new NotConfiguredError(
-            "It seems the config hasn't been set up correctly."
+            "It seems the config hasn't been set up correctly.",
           );
         } else {
           throw new UnableToConnectError('Could not connect: ' + e?.message);
@@ -172,6 +223,9 @@ export default class PostgreSQLDriver extends NymphDriver {
   }
 
   public async inTransaction() {
+    if (this.transaction && this.transaction.count === 0) {
+      this.transaction = null;
+    }
     return !!this.transaction;
   }
 
@@ -190,203 +244,254 @@ export default class PostgreSQLDriver extends NymphDriver {
    * @param etype The entity type to create a table for. If this is blank, the default tables are created.
    * @returns True on success, false on failure.
    */
-  private createTables(etype: string | null = null) {
+  private async createTables(etype: string | null = null) {
+    const connection = await this.getConnection(true);
     if (etype != null) {
       // Create the entity table.
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE TABLE IF NOT EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}`
+          `${this.prefix}entities_${etype}`,
         )} (
           "guid" BYTEA NOT NULL,
           "tags" TEXT[],
           "cdate" DOUBLE PRECISION NOT NULL,
           "mdate" DOUBLE PRECISION NOT NULL,
           PRIMARY KEY ("guid")
-        ) WITH ( OIDS=FALSE );`
+        ) WITH ( OIDS=FALSE );`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `ALTER TABLE ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}`
-        )} OWNER TO ${PostgreSQLDriver.escape(this.config.user)};`
+          `${this.prefix}entities_${etype}`,
+        )} OWNER TO ${PostgreSQLDriver.escape(this.config.user)};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}_id_cdate`
-        )};`
+          `${this.prefix}entities_${etype}_id_cdate`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}_id_cdate`
+          `${this.prefix}entities_${etype}_id_cdate`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}`
-        )} USING btree ("cdate");`
+          `${this.prefix}entities_${etype}`,
+        )} USING btree ("cdate");`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}_id_mdate`
-        )};`
+          `${this.prefix}entities_${etype}_id_mdate`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}_id_mdate`
+          `${this.prefix}entities_${etype}_id_mdate`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}`
-        )} USING btree ("mdate");`
+          `${this.prefix}entities_${etype}`,
+        )} USING btree ("mdate");`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}_id_tags`
-        )};`
+          `${this.prefix}entities_${etype}_id_tags`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}_id_tags`
+          `${this.prefix}entities_${etype}_id_tags`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}`
-        )} USING gin ("tags");`
+          `${this.prefix}entities_${etype}`,
+        )} USING gin ("tags");`,
+        { connection },
       );
       // Create the data table.
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE TABLE IF NOT EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}`
+          `${this.prefix}data_${etype}`,
         )} (
           "guid" BYTEA NOT NULL,
           "name" TEXT NOT NULL,
-          "value" TEXT NOT NULL,
+          "value" CHARACTER(1) NOT NULL,
+          "json" JSONB,
+          "string" TEXT,
+          "number" DOUBLE PRECISION,
+          "truthy" BOOLEAN,
           PRIMARY KEY ("guid", "name"),
           FOREIGN KEY ("guid")
             REFERENCES ${PostgreSQLDriver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} ("guid") MATCH SIMPLE ON UPDATE NO ACTION ON DELETE CASCADE
-        ) WITH ( OIDS=FALSE );`
+        ) WITH ( OIDS=FALSE );`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `ALTER TABLE ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}`
-        )} OWNER TO ${PostgreSQLDriver.escape(this.config.user)};`
+          `${this.prefix}data_${etype}`,
+        )} OWNER TO ${PostgreSQLDriver.escape(this.config.user)};`,
+        { connection },
+      );
+      await this.queryRun(
+        `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
+          `${this.prefix}data_${etype}_id_guid`,
+        )};`,
+        { connection },
+      );
+      await this.queryRun(
+        `CREATE INDEX ${PostgreSQLDriver.escape(
+          `${this.prefix}data_${etype}_id_guid`,
+        )} ON ${PostgreSQLDriver.escape(
+          `${this.prefix}data_${etype}`,
+        )} USING btree ("guid");`,
+        { connection },
+      );
+      await this.queryRun(
+        `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
+          `${this.prefix}data_${etype}_id_guid_name`,
+        )};`,
+        { connection },
+      );
+      await this.queryRun(
+        `CREATE INDEX ${PostgreSQLDriver.escape(
+          `${this.prefix}data_${etype}_id_guid_name`,
+        )} ON ${PostgreSQLDriver.escape(
+          `${this.prefix}data_${etype}`,
+        )} USING btree ("guid", "name");`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}_id_guid`
-        )};`
+          `${this.prefix}data_${etype}_id_guid_name__user`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}_id_guid`
+          `${this.prefix}data_${etype}_id_guid_name__user`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}`
-        )} USING btree ("guid");`
+          `${this.prefix}data_${etype}`,
+        )} USING btree ("guid") WHERE "name" = 'user'::text;`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}_id_name`
-        )};`
+          `${this.prefix}data_${etype}_id_guid_name__group`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}_id_name`
+          `${this.prefix}data_${etype}_id_guid_name__group`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}`
-        )} USING btree ("name");`
+          `${this.prefix}data_${etype}`,
+        )} USING btree ("guid") WHERE "name" = 'group'::text;`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}_id_guid_name__user`
-        )};`
+          `${this.prefix}data_${etype}_id_name`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}_id_guid_name__user`
+          `${this.prefix}data_${etype}_id_name`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}`
-        )} USING btree ("guid") WHERE "name" = 'user'::text;`
+          `${this.prefix}data_${etype}`,
+        )} USING btree ("name");`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}_id_guid_name__group`
-        )};`
+          `${this.prefix}data_${etype}_id_name_string`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}_id_guid_name__group`
+          `${this.prefix}data_${etype}_id_name_string`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}`
-        )} USING btree ("guid") WHERE "name" = 'group'::text;`
+          `${this.prefix}data_${etype}`,
+        )} USING btree ("name", LEFT("string", 512));`,
+        { connection },
       );
-      // Create the data comparisons table.
-      this.queryRunSync(
-        `CREATE TABLE IF NOT EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}`
-        )} (
-          "guid" BYTEA NOT NULL,
-          "name" TEXT NOT NULL,
-          "truthy" BOOLEAN,
-          "string" TEXT,
-          "number" DOUBLE PRECISION,
-          PRIMARY KEY ("guid", "name"),
-          FOREIGN KEY ("guid")
-            REFERENCES ${PostgreSQLDriver.escape(
-              `${this.prefix}entities_${etype}`
-            )} ("guid") MATCH SIMPLE ON UPDATE NO ACTION ON DELETE CASCADE
-        ) WITH ( OIDS=FALSE );`
+      await this.queryRun(
+        `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
+          `${this.prefix}data_${etype}_id_name_number`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
-        `ALTER TABLE ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}`
-        )} OWNER TO ${PostgreSQLDriver.escape(this.config.user)};`
+      await this.queryRun(
+        `CREATE INDEX ${PostgreSQLDriver.escape(
+          `${this.prefix}data_${etype}_id_name_number`,
+        )} ON ${PostgreSQLDriver.escape(
+          `${this.prefix}data_${etype}`,
+        )} USING btree ("name", "number");`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}_id_guid`
-        )};`
+          `${this.prefix}data_${etype}_id_name_truthy`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}_id_guid`
+          `${this.prefix}data_${etype}_id_name_truthy`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}`
-        )} USING btree ("guid");`
+          `${this.prefix}data_${etype}`,
+        )} USING btree ("name") WHERE "truthy" = TRUE;`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}_id_name`
-        )};`
+          `${this.prefix}data_${etype}_id_name_falsy`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}_id_name`
+          `${this.prefix}data_${etype}_id_name_falsy`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}`
-        )} USING btree ("name");`
+          `${this.prefix}data_${etype}`,
+        )} USING btree ("name") WHERE "truthy" <> TRUE;`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}_id_guid_name_truthy`
-        )};`
+          `${this.prefix}data_${etype}_id_string`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}_id_guid_name_truthy`
+          `${this.prefix}data_${etype}_id_string`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}`
-        )} USING btree ("guid", "name") WHERE "truthy" = TRUE;`
+          `${this.prefix}data_${etype}`,
+        )} USING gin ("string" gin_trgm_ops);`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}_id_guid_name_falsy`
-        )};`
+          `${this.prefix}data_${etype}_id_json`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}_id_guid_name_falsy`
+          `${this.prefix}data_${etype}_id_json`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}`
-        )} USING btree ("guid", "name") WHERE "truthy" <> TRUE;`
+          `${this.prefix}data_${etype}`,
+        )} USING gin ("json");`,
+        { connection },
       );
       // Create the references table.
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE TABLE IF NOT EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}`
+          `${this.prefix}references_${etype}`,
         )} (
           "guid" BYTEA NOT NULL,
           "name" TEXT NOT NULL,
@@ -394,74 +499,106 @@ export default class PostgreSQLDriver extends NymphDriver {
           PRIMARY KEY ("guid", "name", "reference"),
           FOREIGN KEY ("guid")
             REFERENCES ${PostgreSQLDriver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} ("guid") MATCH SIMPLE ON UPDATE NO ACTION ON DELETE CASCADE
-        ) WITH ( OIDS=FALSE );`
+        ) WITH ( OIDS=FALSE );`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `ALTER TABLE ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}`
-        )} OWNER TO ${PostgreSQLDriver.escape(this.config.user)};`
+          `${this.prefix}references_${etype}`,
+        )} OWNER TO ${PostgreSQLDriver.escape(this.config.user)};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}_id_guid`
-        )};`
+          `${this.prefix}references_${etype}_id_guid`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}_id_guid`
+          `${this.prefix}references_${etype}_id_guid`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}`
-        )} USING btree ("guid");`
+          `${this.prefix}references_${etype}`,
+        )} USING btree ("guid");`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}_id_name`
-        )};`
+          `${this.prefix}references_${etype}_id_name`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}_id_name`
+          `${this.prefix}references_${etype}_id_name`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}`
-        )} USING btree ("name");`
+          `${this.prefix}references_${etype}`,
+        )} USING btree ("name");`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `DROP INDEX IF EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}_id_reference`
-        )};`
+          `${this.prefix}references_${etype}_id_name_reference`,
+        )};`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE INDEX ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}_id_reference`
+          `${this.prefix}references_${etype}_id_name_reference`,
         )} ON ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}`
-        )} USING btree ("reference");`
+          `${this.prefix}references_${etype}`,
+        )} USING btree ("name", "reference");`,
+        { connection },
+      );
+      // Create the unique strings table.
+      await this.queryRun(
+        `CREATE TABLE IF NOT EXISTS ${PostgreSQLDriver.escape(
+          `${this.prefix}uniques_${etype}`,
+        )} (
+          "guid" BYTEA NOT NULL,
+          "unique" TEXT NOT NULL UNIQUE,
+          PRIMARY KEY ("guid", "unique"),
+          FOREIGN KEY ("guid")
+            REFERENCES ${PostgreSQLDriver.escape(
+              `${this.prefix}entities_${etype}`,
+            )} ("guid") MATCH SIMPLE ON UPDATE NO ACTION ON DELETE CASCADE
+        ) WITH ( OIDS=FALSE );`,
+        { connection },
       );
     } else {
+      // Add trigram extensions.
+      try {
+        await this.queryRun(`CREATE EXTENSION pg_trgm;`, { connection });
+      } catch (e: any) {
+        // Ignore errors.
+      }
       // Create the UID table.
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE TABLE IF NOT EXISTS ${PostgreSQLDriver.escape(
-          `${this.prefix}uids`
+          `${this.prefix}uids`,
         )} (
           "name" TEXT NOT NULL,
           "cur_uid" BIGINT NOT NULL,
           PRIMARY KEY ("name")
-        ) WITH ( OIDS = FALSE );`
+        ) WITH ( OIDS = FALSE );`,
+        { connection },
       );
-      this.queryRunSync(
+      await this.queryRun(
         `ALTER TABLE ${PostgreSQLDriver.escape(
-          `${this.prefix}uids`
-        )} OWNER TO ${PostgreSQLDriver.escape(this.config.user)};`
+          `${this.prefix}uids`,
+        )} OWNER TO ${PostgreSQLDriver.escape(this.config.user)};`,
+        { connection },
       );
     }
+    connection.done();
     return true;
   }
 
   private translateQuery(
     origQuery: string,
-    origParams: { [k: string]: any }
+    origParams: { [k: string]: any },
   ): { query: string; params: any[] } {
     const params: any[] = [];
     let query = origQuery;
@@ -481,61 +618,39 @@ export default class PostgreSQLDriver extends NymphDriver {
   private async query<T extends () => any>(
     runQuery: T,
     query: string,
-    etypes: string[] = []
+    etypes: string[] = [],
     // @ts-ignore: The return type of T is a promise.
   ): ReturnType<T> {
     try {
+      this.nymph.config.debugInfo('postgresql:query', query);
       return await runQuery();
     } catch (e: any) {
       const errorCode = e?.code;
-      if (errorCode === '42P01' && this.createTables()) {
+      if (errorCode === '42P01' && (await this.createTables())) {
         // If the tables don't exist yet, create them.
         for (let etype of etypes) {
-          this.createTables(etype);
+          await this.createTables(etype);
         }
         try {
           return await runQuery();
         } catch (e2: any) {
           throw new QueryFailedError(
             'Query failed: ' + e2?.code + ' - ' + e2?.message,
-            query
-          );
-        }
-      } else {
-        throw e;
-      }
-    }
-  }
-
-  private querySync<T extends () => any>(
-    runQuery: T,
-    query: string,
-    etypes: string[] = []
-  ): ReturnType<T> {
-    try {
-      return runQuery();
-    } catch (e: any) {
-      const errorCode = e?.code;
-      if (errorCode === '42P01' && this.createTables()) {
-        // If the tables don't exist yet, create them.
-        for (let etype of etypes) {
-          this.createTables(etype);
-        }
-        try {
-          return runQuery();
-        } catch (e2: any) {
-          throw new QueryFailedError(
-            'Query failed: ' + e2?.code + ' - ' + e2?.message,
-            query
+            query,
           );
         }
+      } else if (errorCode === '23505') {
+        throw new EntityUniqueConstraintError(`Unique constraint violation.`);
       } else {
-        throw e;
+        throw new QueryFailedError(
+          'Query failed: ' + e?.code + ' - ' + e?.message,
+          query,
+        );
       }
     }
   }
 
-  private queryIter(
+  private queryArray(
     query: string,
     {
       etypes = [],
@@ -543,11 +658,11 @@ export default class PostgreSQLDriver extends NymphDriver {
     }: {
       etypes?: string[];
       params?: { [k: string]: any };
-    } = {}
+    } = {},
   ) {
     const { query: newQuery, params: newParams } = this.translateQuery(
       query,
-      params
+      params,
     );
     return this.query(
       async () => {
@@ -558,64 +673,65 @@ export default class PostgreSQLDriver extends NymphDriver {
                 .query(newQuery, newParams)
                 .then(
                   (results) => resolve(results),
-                  (error) => reject(error)
+                  (error) => reject(error),
                 );
             } catch (e) {
               reject(e);
             }
-          }
+          },
         );
         return results.rows;
       },
       `${query} -- ${JSON.stringify(params)}`,
-      etypes
+      etypes,
     );
   }
 
-  private queryIterSync(
+  private async queryIter(
     query: string,
     {
       etypes = [],
       params = {},
-    }: { etypes?: string[]; params?: { [k: string]: any } } = {}
+    }: {
+      etypes?: string[];
+      params?: { [k: string]: any };
+    } = {},
   ) {
     const { query: newQuery, params: newParams } = this.translateQuery(
       query,
-      params
+      params,
     );
-    return this.querySync(
-      () => {
-        const output = cp.spawnSync(
-          process.argv0,
-          [__dirname + '/runPostgresqlSync.js'],
-          {
-            input: JSON.stringify({
-              postgresqlConfig: this.postgresqlConfig,
-              query: newQuery,
-              params: newParams,
-            }),
-            timeout: 30000,
-            maxBuffer: 100 * 1024 * 1024,
-            encoding: 'utf8',
-            windowsHide: true,
+    const that = this;
+
+    return this.query(
+      async function* (): AsyncGenerator<any, void, false | undefined> {
+        const transaction = !!that.transaction?.connection;
+        const connection = await that.getConnection();
+        const cursor = new Cursor(newQuery, newParams);
+        const iter = connection.client.query(cursor);
+
+        while (true) {
+          const rows = await iter.read(100);
+
+          if (!rows.length) {
+            await new Promise<void>((resolve) => {
+              iter.close(() => {
+                if (!transaction) {
+                  connection.done();
+                }
+                resolve();
+              });
+            });
+            return;
+          }
+
+          for (let row of rows) {
+            yield row;
           }
-        );
-        try {
-          return JSON.parse(output.stdout).rows;
-        } catch (e) {
-          // Do nothing.
-        }
-        if (output.status === 0) {
-          throw new Error('Unknown parse error.');
-        }
-        const err = JSON.parse(output.stderr);
-        const e = new Error(err.name);
-        for (const name in err) {
-          (e as any)[name] = err[name];
         }
       },
       `${query} -- ${JSON.stringify(params)}`,
-      etypes
+      etypes,
     );
   }
 
@@ -627,11 +743,11 @@ export default class PostgreSQLDriver extends NymphDriver {
     }: {
       etypes?: string[];
       params?: { [k: string]: any };
-    } = {}
+    } = {},
   ) {
     const { query: newQuery, params: newParams } = this.translateQuery(
       query,
-      params
+      params,
     );
     return this.query(
       async () => {
@@ -642,17 +758,17 @@ export default class PostgreSQLDriver extends NymphDriver {
                 .query(newQuery, newParams)
                 .then(
                   (results) => resolve(results),
-                  (error) => reject(error)
+                  (error) => reject(error),
                 );
             } catch (e) {
               reject(e);
             }
-          }
+          },
         );
         return results.rows[0];
       },
       `${query} -- ${JSON.stringify(params)}`,
-      etypes
+      etypes,
     );
   }
 
@@ -661,90 +777,47 @@ export default class PostgreSQLDriver extends NymphDriver {
     {
       etypes = [],
       params = {},
+      connection,
     }: {
       etypes?: string[];
       params?: { [k: string]: any };
-    } = {}
+      connection?: PostgreSQLDriverConnection;
+    } = {},
   ) {
     const { query: newQuery, params: newParams } = this.translateQuery(
       query,
-      params
+      params,
     );
     return this.query(
       async () => {
         const results: QueryResult<any> = await new Promise(
           (resolve, reject) => {
             try {
-              (this.transaction?.connection?.client ?? this.link)
+              (
+                (connection ?? this.transaction?.connection)?.client ??
+                this.link
+              )
                 .query(newQuery, newParams)
                 .then(
                   (results) => resolve(results),
-                  (error) => reject(error)
+                  (error) => reject(error),
                 );
             } catch (e) {
               reject(e);
             }
-          }
+          },
         );
         return { rowCount: results.rowCount ?? 0 };
       },
       `${query} -- ${JSON.stringify(params)}`,
-      etypes
-    );
-  }
-
-  private queryRunSync(
-    query: string,
-    {
-      etypes = [],
-      params = {},
-    }: { etypes?: string[]; params?: { [k: string]: any } } = {}
-  ) {
-    const { query: newQuery, params: newParams } = this.translateQuery(
-      query,
-      params
-    );
-    return this.querySync(
-      () => {
-        const output = cp.spawnSync(
-          process.argv0,
-          [__dirname + '/runPostgresqlSync.js'],
-          {
-            input: JSON.stringify({
-              postgresqlConfig: this.postgresqlConfig,
-              query: newQuery,
-              params: newParams,
-            }),
-            timeout: 30000,
-            maxBuffer: 100 * 1024 * 1024,
-            encoding: 'utf8',
-            windowsHide: true,
-          }
-        );
-        try {
-          const results = JSON.parse(output.stdout);
-          return { rowCount: results.rowCount ?? 0 };
-        } catch (e) {
-          // Do nothing.
-        }
-        if (output.status === 0) {
-          throw new Error('Unknown parse error.');
-        }
-        const err = JSON.parse(output.stderr);
-        const e = new Error(err.name);
-        for (const name in err) {
-          (e as any)[name] = err[name];
-        }
-      },
-      `${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.transaction || this.transaction.count === 0) {
@@ -764,7 +837,7 @@ export default class PostgreSQLDriver extends NymphDriver {
 
   public async deleteEntityByID(
     guid: string,
-    className?: EntityConstructor | string | null
+    className?: EntityConstructor | string | null,
   ) {
     let EntityClass: EntityConstructor;
     if (typeof className === 'string' || className == null) {
@@ -778,58 +851,60 @@ export default class PostgreSQLDriver extends NymphDriver {
     try {
       await this.queryRun(
         `DELETE FROM ${PostgreSQLDriver.escape(
-          `${this.prefix}entities_${etype}`
+          `${this.prefix}entities_${etype}`,
         )} WHERE "guid"=decode(@guid, 'hex');`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
       );
       await this.queryRun(
         `DELETE FROM ${PostgreSQLDriver.escape(
-          `${this.prefix}data_${etype}`
+          `${this.prefix}data_${etype}`,
         )} WHERE "guid"=decode(@guid, 'hex');`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
       );
       await this.queryRun(
         `DELETE FROM ${PostgreSQLDriver.escape(
-          `${this.prefix}comparisons_${etype}`
+          `${this.prefix}references_${etype}`,
         )} WHERE "guid"=decode(@guid, 'hex');`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
       );
       await this.queryRun(
         `DELETE FROM ${PostgreSQLDriver.escape(
-          `${this.prefix}references_${etype}`
+          `${this.prefix}uniques_${etype}`,
         )} WHERE "guid"=decode(@guid, 'hex');`,
         {
           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('postgresql', `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) {
@@ -838,103 +913,143 @@ export default class PostgreSQLDriver extends NymphDriver {
     }
     await this.queryRun(
       `DELETE FROM ${PostgreSQLDriver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} WHERE "name"=@name;`,
       {
         params: {
           name,
         },
-      }
+      },
     );
     return true;
   }
 
-  protected async exportEntities(writeLine: (line: string) => void) {
-    writeLine('#nex2');
-    writeLine('# Nymph Entity Exchange v2');
-    writeLine('# http://nymph.io');
-    writeLine('#');
-    writeLine('# Generation Time: ' + new Date().toLocaleString());
-    writeLine('');
+  public async *exportDataIterator(): AsyncGenerator<
+    { type: 'comment' | 'uid' | 'entity'; content: string },
+    void,
+    false | undefined
+  > {
+    if (
+      yield {
+        type: 'comment',
+        content: `#nex2
+# Nymph Entity Exchange v2
+# http://nymph.io
+#
+# Generation Time: ${new Date().toLocaleString()}
+`,
+      }
+    ) {
+      return;
+    }
+
+    if (
+      yield {
+        type: 'comment',
+        content: `
 
-    writeLine('#');
-    writeLine('# UIDs');
-    writeLine('#');
-    writeLine('');
+#
+# UIDs
+#
+
+`,
+      }
+    ) {
+      return;
+    }
 
     // Export UIDs.
     let uids = await this.queryIter(
       `SELECT * FROM ${PostgreSQLDriver.escape(
-        `${this.prefix}uids`
-      )} ORDER BY "name";`
+        `${this.prefix}uids`,
+      )} ORDER BY "name";`,
     );
-    for (const uid of uids) {
-      writeLine(`<${uid.name}>[${uid.cur_uid}]`);
+    for await (const uid of uids) {
+      if (yield { type: 'uid', content: `<${uid.name}>[${uid.cur_uid}]\n` }) {
+        return;
+      }
     }
 
-    writeLine('');
-    writeLine('#');
-    writeLine('# Entities');
-    writeLine('#');
-    writeLine('');
+    if (
+      yield {
+        type: 'comment',
+        content: `
+
+#
+# Entities
+#
+
+`,
+      }
+    ) {
+      return;
+    }
 
     // Get the etypes.
-    const tables = await this.queryIter(
-      'SELECT relname FROM pg_stat_user_tables ORDER BY relname;'
+    const tables = await this.queryArray(
+      'SELECT "table_name" AS "table_name" FROM "information_schema"."tables" WHERE "table_catalog"=@db AND "table_schema"=\'public\' AND "table_name" LIKE @prefix;',
+      {
+        params: {
+          db: this.config.database,
+          prefix: this.prefix + 'entities_' + '%',
+        },
+      },
     );
     const etypes = [];
-    for (const tableRow of tables) {
-      const table = tableRow.relname;
-      if (table.startsWith(this.prefix + 'entities_')) {
-        etypes.push(table.substr((this.prefix + 'entities_').length));
-      }
+    for (const table of tables) {
+      etypes.push(table.table_name.substr((this.prefix + 'entities_').length));
     }
 
     for (const etype of etypes) {
       // Export entities.
-      const dataIterator = (
-        await this.queryIter(
-          `SELECT encode(e."guid", 'hex') AS "guid", e."tags", e."cdate", e."mdate", d."name" AS "dname", d."value" AS "dvalue", c."string", c."number"
+      const dataIterator = await this.queryIter(
+        `SELECT encode(e."guid", 'hex') AS "guid", e."tags", e."cdate", e."mdate", d."name", d."value", d."json", d."string", d."number"
           FROM ${PostgreSQLDriver.escape(`${this.prefix}entities_${etype}`)} e
           LEFT JOIN ${PostgreSQLDriver.escape(
-            `${this.prefix}data_${etype}`
+            `${this.prefix}data_${etype}`,
           )} d ON e."guid"=d."guid"
-          INNER JOIN ${PostgreSQLDriver.escape(
-            `${this.prefix}comparisons_${etype}`
-          )} c ON d."guid"=c."guid" AND d."name"=c."name"
-          ORDER BY e."guid";`
-        )
-      )[Symbol.iterator]();
-      let datum = dataIterator.next();
+          ORDER BY e."guid";`,
+      );
+      let datum = await dataIterator.next();
       while (!datum.done) {
         const guid = datum.value.guid;
-        const tags = datum.value.tags.join(',');
+        const tags = datum.value.tags.filter((tag: string) => tag).join(',');
         const cdate = datum.value.cdate;
         const mdate = datum.value.mdate;
-        writeLine(`{${guid}}<${etype}>[${tags}]`);
-        writeLine(`\tcdate=${JSON.stringify(cdate)}`);
-        writeLine(`\tmdate=${JSON.stringify(mdate)}`);
-        if (datum.value.dname != null) {
+        let currentEntityExport: string[] = [];
+        currentEntityExport.push(`{${guid}}<${etype}>[${tags}]`);
+        currentEntityExport.push(`\tcdate=${JSON.stringify(cdate)}`);
+        currentEntityExport.push(`\tmdate=${JSON.stringify(mdate)}`);
+        if (datum.value.name != null) {
           // This do will keep going and adding the data until the
           // next entity is reached. $row will end on the next entity.
           do {
             const value =
-              datum.value.dvalue === 'N'
+              datum.value.value === 'N'
                 ? JSON.stringify(Number(datum.value.number))
-                : datum.value.dvalue === 'S'
-                ? JSON.stringify(datum.value.string)
-                : datum.value.dvalue;
-            writeLine(`\t${datum.value.dname}=${value}`);
-            datum = dataIterator.next();
+                : datum.value.value === 'S'
+                  ? JSON.stringify(
+                      PostgreSQLDriver.unescapeNulls(datum.value.string),
+                    )
+                  : datum.value.value === 'J'
+                    ? PostgreSQLDriver.unescapeNullSequences(
+                        JSON.stringify(datum.value.json),
+                      )
+                    : datum.value.value;
+            currentEntityExport.push(`\t${datum.value.name}=${value}`);
+            datum = await dataIterator.next();
           } while (!datum.done && datum.value.guid === guid);
         } else {
           // Make sure that datum is incremented :)
-          datum = dataIterator.next();
+          datum = await dataIterator.next();
+        }
+        currentEntityExport.push('');
+
+        if (yield { type: 'entity', content: currentEntityExport.join('\n') }) {
+          return;
         }
       }
     }
-
-    return;
   }
 
   /**
@@ -955,21 +1070,22 @@ export default class PostgreSQLDriver extends NymphDriver {
     params: { [k: string]: any } = {},
     subquery = false,
     tableSuffix = '',
-    etypes: string[] = []
+    etypes: string[] = [],
+    guidSelector: string | undefined = undefined,
   ) {
     if (typeof options.class?.alterOptions === 'function') {
       options = options.class.alterOptions(options);
     }
     const eTable = `e${tableSuffix}`;
     const dTable = `d${tableSuffix}`;
-    const cTable = `c${tableSuffix}`;
     const fTable = `f${tableSuffix}`;
     const ieTable = `ie${tableSuffix}`;
     const countTable = `count${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) {
@@ -1013,12 +1129,12 @@ export default class PostgreSQLDriver extends NymphDriver {
                 }
                 const name = `param${++count.i}`;
                 curQuery +=
-                  ieTable +
-                  '."guid" ' +
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  'IN (SELECT "guid" FROM ' +
+                  'EXISTS (SELECT "guid" FROM ' +
                   PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
-                  ' WHERE "name"=@' +
+                  ' WHERE "guid"=' +
+                  ieTable +
+                  '."guid" AND "name"=@' +
                   name +
                   ')';
                 params[name] = curVar;
@@ -1048,12 +1164,11 @@ export default class PostgreSQLDriver extends NymphDriver {
                   const name = `param${++count.i}`;
                   curQuery +=
                     (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                    'EXISTS (SELECT "guid" FROM ' +
+                    PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                    ' WHERE "guid"=' +
                     ieTable +
-                    '."guid" IN (SELECT "guid" FROM ' +
-                    PostgreSQLDriver.escape(
-                      this.prefix + 'comparisons_' + etype
-                    ) +
-                    ' WHERE "name"=@' +
+                    '."guid" AND "name"=@' +
                     name +
                     ' AND "truthy"=TRUE)';
                   params[name] = curVar;
@@ -1098,12 +1213,11 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
                   ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
-                  PostgreSQLDriver.escape(
-                    this.prefix + 'comparisons_' + etype
-                  ) +
-                  ' WHERE "name"=@' +
+                  '."guid" AND "name"=@' +
                   name +
                   ' AND "number"=@' +
                   value +
@@ -1118,18 +1232,19 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
                   ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
-                  PostgreSQLDriver.escape(
-                    this.prefix + 'comparisons_' + etype
-                  ) +
-                  ' WHERE "name"=@' +
+                  '."guid" AND "name"=@' +
                   name +
-                  ' AND "string"=@' +
-                  value +
+                  ' AND "string"=' +
+                  (curValue[1].length < 512
+                    ? 'LEFT(@' + value + ', 512)'
+                    : '@' + value) +
                   ')';
                 params[name] = curValue[0];
-                params[value] = curValue[1];
+                params[value] = PostgreSQLDriver.escapeNulls(curValue[1]);
               } else {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1147,16 +1262,17 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
+                  'EXISTS (SELECT "guid" FROM ' +
                   PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
-                  ' WHERE "name"=@' +
+                  ' WHERE "guid"=' +
+                  ieTable +
+                  '."guid" AND "name"=@' +
                   name +
-                  ' AND "value"=@' +
+                  ' AND "json"=@' +
                   value +
                   ')';
                 params[name] = curValue[0];
-                params[value] = svalue;
+                params[value] = PostgreSQLDriver.escapeNullSequences(svalue);
               }
               break;
             case 'contain':
@@ -1169,7 +1285,7 @@ export default class PostgreSQLDriver extends NymphDriver {
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   ieTable +
-                  '."cdate"=' +
+                  '."cdate"=@' +
                   cdate;
                 params[cdate] = isNaN(Number(curValue[1]))
                   ? null
@@ -1183,7 +1299,7 @@ export default class PostgreSQLDriver extends NymphDriver {
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   ieTable +
-                  '."mdate"=' +
+                  '."mdate"=@' +
                   mdate;
                 params[mdate] = isNaN(Number(curValue[1]))
                   ? null
@@ -1194,57 +1310,34 @@ export default class PostgreSQLDriver extends NymphDriver {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
                 let svalue: string;
-                let stringValue: string;
                 if (
                   curValue[1] instanceof Object &&
                   typeof curValue[1].toReference === 'function'
                 ) {
                   svalue = JSON.stringify(curValue[1].toReference());
-                  stringValue = `${curValue[1].toReference()}`;
-                } else {
+                } else if (
+                  typeof curValue[1] === 'string' ||
+                  typeof curValue[1] === 'number'
+                ) {
                   svalue = JSON.stringify(curValue[1]);
-                  stringValue = `${curValue[1]}`;
+                } else {
+                  svalue = JSON.stringify([curValue[1]]);
                 }
                 const name = `param${++count.i}`;
                 const value = `param${++count.i}`;
-                if (typeof curValue[1] === 'string') {
-                  const stringParam = `param${++count.i}`;
-                  curQuery +=
-                    (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                    '(' +
-                    ieTable +
-                    '."guid" IN (SELECT "guid" FROM ' +
-                    PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
-                    ' WHERE "name"=@' +
-                    name +
-                    ' AND position(@' +
-                    value +
-                    ' IN "value")>0) OR ' +
-                    ieTable +
-                    '."guid" IN (SELECT "guid" FROM ' +
-                    PostgreSQLDriver.escape(
-                      this.prefix + 'comparisons_' + etype
-                    ) +
-                    ' WHERE "name"=@' +
-                    name +
-                    ' AND "string"=@' +
-                    stringParam +
-                    '))';
-                  params[stringParam] = stringValue;
-                } else {
-                  curQuery +=
-                    (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                    ieTable +
-                    '."guid" IN (SELECT "guid" FROM ' +
-                    PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
-                    ' WHERE "name"=@' +
-                    name +
-                    ' AND position(@' +
-                    value +
-                    ' IN "value")>0)';
-                }
+                curQuery +=
+                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
+                  ieTable +
+                  '."guid" AND "name"=@' +
+                  name +
+                  ' AND "json" @> @' +
+                  value +
+                  ')';
                 params[name] = curValue[0];
-                params[value] = svalue;
+                params[value] = PostgreSQLDriver.escapeNullSequences(svalue);
               }
               break;
             case 'match':
@@ -1285,18 +1378,17 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
                   ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
-                  PostgreSQLDriver.escape(
-                    this.prefix + 'comparisons_' + etype
-                  ) +
-                  ' WHERE "name"=@' +
+                  '."guid" AND "name"=@' +
                   name +
                   ' AND "string" ~ @' +
                   value +
                   ')';
                 params[name] = curValue[0];
-                params[value] = curValue[1];
+                params[value] = PostgreSQLDriver.escapeNulls(curValue[1]);
               }
               break;
             case 'imatch':
@@ -1337,18 +1429,17 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
                   ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
-                  PostgreSQLDriver.escape(
-                    this.prefix + 'comparisons_' + etype
-                  ) +
-                  ' WHERE "name"=@' +
+                  '."guid" AND "name"=@' +
                   name +
                   ' AND "string" ~* @' +
                   value +
                   ')';
                 params[name] = curValue[0];
-                params[value] = curValue[1];
+                params[value] = PostgreSQLDriver.escapeNulls(curValue[1]);
               }
               break;
             case 'like':
@@ -1389,18 +1480,17 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
                   ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
-                  PostgreSQLDriver.escape(
-                    this.prefix + 'comparisons_' + etype
-                  ) +
-                  ' WHERE "name"=@' +
+                  '."guid" AND "name"=@' +
                   name +
                   ' AND "string" LIKE @' +
                   value +
                   ')';
                 params[name] = curValue[0];
-                params[value] = curValue[1];
+                params[value] = PostgreSQLDriver.escapeNulls(curValue[1]);
               }
               break;
             case 'ilike':
@@ -1441,18 +1531,17 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
                   ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
-                  PostgreSQLDriver.escape(
-                    this.prefix + 'comparisons_' + etype
-                  ) +
-                  ' WHERE "name"=@' +
+                  '."guid" AND "name"=@' +
                   name +
                   ' AND "string" ILIKE @' +
                   value +
                   ')';
                 params[name] = curValue[0];
-                params[value] = curValue[1];
+                params[value] = PostgreSQLDriver.escapeNulls(curValue[1]);
               }
               break;
             case 'gt':
@@ -1493,12 +1582,11 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
                   ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
-                  PostgreSQLDriver.escape(
-                    this.prefix + 'comparisons_' + etype
-                  ) +
-                  ' WHERE "name"=@' +
+                  '."guid" AND "name"=@' +
                   name +
                   ' AND "number">@' +
                   value +
@@ -1547,12 +1635,11 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
                   ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
-                  PostgreSQLDriver.escape(
-                    this.prefix + 'comparisons_' + etype
-                  ) +
-                  ' WHERE "name"=@' +
+                  '."guid" AND "name"=@' +
                   name +
                   ' AND "number">=@' +
                   value +
@@ -1601,12 +1688,11 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
                   ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
-                  PostgreSQLDriver.escape(
-                    this.prefix + 'comparisons_' + etype
-                  ) +
-                  ' WHERE "name"=@' +
+                  '."guid" AND "name"=@' +
                   name +
                   ' AND "number"<@' +
                   value +
@@ -1655,12 +1741,11 @@ export default class PostgreSQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT "guid" FROM ' +
+                  PostgreSQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE "guid"=' +
                   ieTable +
-                  '."guid" IN (SELECT "guid" FROM ' +
-                  PostgreSQLDriver.escape(
-                    this.prefix + 'comparisons_' + etype
-                  ) +
-                  ' WHERE "name"=@' +
+                  '."guid" AND "name"=@' +
                   name +
                   ' AND "number"<=@' +
                   value +
@@ -1688,10 +1773,11 @@ export default class PostgreSQLDriver extends NymphDriver {
               const guid = `param${++count.i}`;
               curQuery +=
                 (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                ieTable +
-                '."guid" IN (SELECT "guid" FROM ' +
+                'EXISTS (SELECT "guid" FROM ' +
                 PostgreSQLDriver.escape(this.prefix + 'references_' + etype) +
-                ' WHERE "name"=@' +
+                ' WHERE "guid"=' +
+                ieTable +
+                '."guid" AND "name"=@' +
                 name +
                 ' AND "reference"=decode(@' +
                 guid +
@@ -1709,7 +1795,7 @@ export default class PostgreSQLDriver extends NymphDriver {
                 params,
                 true,
                 tableSuffix,
-                etypes
+                etypes,
               );
               if (curQuery) {
                 curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1722,9 +1808,10 @@ export default class PostgreSQLDriver extends NymphDriver {
               break;
             case 'qref':
             case '!qref':
+              const referenceTableSuffix = makeTableSuffix();
               const [qrefOptions, ...qrefSelectors] = curValue[1] as [
                 Options,
-                ...FormattedSelector[]
+                ...FormattedSelector[],
               ];
               const QrefEntityClass = qrefOptions.class as EntityConstructor;
               etypes.push(QrefEntityClass.ETYPE);
@@ -1736,7 +1823,8 @@ export default class PostgreSQLDriver extends NymphDriver {
                 params,
                 false,
                 makeTableSuffix(),
-                etypes
+                etypes,
+                'r' + referenceTableSuffix + '."reference"',
               );
               if (curQuery) {
                 curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1744,12 +1832,19 @@ export default class PostgreSQLDriver extends NymphDriver {
               const qrefName = `param${++count.i}`;
               curQuery +=
                 (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                ieTable +
-                '."guid" IN (SELECT "guid" FROM ' +
+                'EXISTS (SELECT "guid" FROM ' +
                 PostgreSQLDriver.escape(this.prefix + 'references_' + etype) +
-                ' WHERE "name"=@' +
+                ' r' +
+                referenceTableSuffix +
+                ' WHERE r' +
+                referenceTableSuffix +
+                '."guid"=' +
+                ieTable +
+                '."guid" AND r' +
+                referenceTableSuffix +
+                '."name"=@' +
                 qrefName +
-                ' AND "reference" IN (' +
+                ' AND EXISTS (' +
                 qrefQuery.query +
                 '))';
               params[qrefName] = curValue[0];
@@ -1757,22 +1852,42 @@ export default class PostgreSQLDriver extends NymphDriver {
           }
         }
         return curQuery;
-      }
+      },
     );
 
     let sortBy: string;
+    let sortByInner: string;
+    let sortJoin = '';
+    let sortJoinInner = '';
+    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 ${PostgreSQLDriver.escape(this.prefix + 'data_' + etype)}
+            WHERE "name"=@${name}
+            ORDER BY "number"${order}, "string"${order}
+          ) ${sTable} ON ${eTable}."guid"=${sTable}."guid"`;
+        sortJoinInner = `LEFT JOIN (
+            SELECT "guid", "string", "number"
+            FROM ${PostgreSQLDriver.escape(this.prefix + 'data_' + etype)}
+            WHERE "name"=@${name}
+            ORDER BY "number"${order}, "string"${order}
+          ) ${sTable} ON ${ieTable}."guid"=${sTable}."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) {
@@ -1782,31 +1897,34 @@ export default class PostgreSQLDriver extends NymphDriver {
         let limit = '';
         if ('limit' in options) {
           limit = ` LIMIT ${Math.floor(
-            isNaN(Number(options.limit)) ? 0 : Number(options.limit)
+            isNaN(Number(options.limit)) ? 0 : Number(options.limit),
           )}`;
         }
         let offset = '';
         if ('offset' in options) {
           offset = ` OFFSET ${Math.floor(
-            isNaN(Number(options.offset)) ? 0 : Number(options.offset)
+            isNaN(Number(options.offset)) ? 0 : Number(options.offset),
           )}`;
         }
         const whereClause = queryParts.join(') AND (');
+        const guidClause = guidSelector
+          ? `${ieTable}."guid"=${guidSelector} AND `
+          : '';
         if (options.return === 'count') {
           if (limit || offset) {
             query = `SELECT COUNT(${countTable}."guid") AS "count" FROM (
-                SELECT COUNT(${ieTable}."guid") AS "guid"
+                SELECT ${ieTable}."guid" AS "guid"
                 FROM ${PostgreSQLDriver.escape(
-                  `${this.prefix}entities_${etype}`
+                  `${this.prefix}entities_${etype}`,
                 )} ${ieTable}
-                WHERE (${whereClause})${limit}${offset}
+                WHERE ${guidClause}(${whereClause})${limit}${offset}
               ) ${countTable}`;
           } else {
             query = `SELECT COUNT(${ieTable}."guid") AS "count"
               FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}entities_${etype}`
+                `${this.prefix}entities_${etype}`,
               )} ${ieTable}
-              WHERE (${whereClause})`;
+              WHERE ${guidClause}(${whereClause})`;
           }
         } else if (options.return === 'guid') {
           const guidColumn =
@@ -1815,10 +1933,11 @@ export default class PostgreSQLDriver extends NymphDriver {
               : `${ieTable}."guid"`;
           query = `SELECT ${guidColumn} AS "guid"
             FROM ${PostgreSQLDriver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} ${ieTable}
-            WHERE (${whereClause})
-            ORDER BY ${ieTable}.${sortBy}${limit}${offset}`;
+            ${sortJoinInner}
+            WHERE ${guidClause}(${whereClause})
+            ORDER BY ${sortByInner}, ${ieTable}."guid"${limit}${offset}`;
         } else {
           query = `SELECT
               encode(${eTable}."guid", 'hex') AS "guid",
@@ -1827,26 +1946,26 @@ export default class PostgreSQLDriver extends NymphDriver {
               ${eTable}."mdate",
               ${dTable}."name",
               ${dTable}."value",
-              ${cTable}."string",
-              ${cTable}."number"
+              ${dTable}."json",
+              ${dTable}."string",
+              ${dTable}."number"
             FROM ${PostgreSQLDriver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} ${eTable}
             LEFT JOIN ${PostgreSQLDriver.escape(
-              `${this.prefix}data_${etype}`
+              `${this.prefix}data_${etype}`,
             )} ${dTable} ON ${eTable}."guid"=${dTable}."guid"
-            INNER JOIN ${PostgreSQLDriver.escape(
-              `${this.prefix}comparisons_${etype}`
-            )} ${cTable} ON ${dTable}."guid"=${cTable}."guid" AND ${dTable}."name"=${cTable}."name"
+            ${sortJoin}
             INNER JOIN (
               SELECT ${ieTable}."guid"
               FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}entities_${etype}`
+                `${this.prefix}entities_${etype}`,
               )} ${ieTable}
-              WHERE (${whereClause})
-              ORDER BY ${ieTable}.${sortBy}${limit}${offset}
+              ${sortJoinInner}
+              WHERE ${guidClause}(${whereClause})
+              ORDER BY ${sortByInner}${limit}${offset}
             ) ${fTable} ON ${eTable}."guid"=${fTable}."guid"
-            ORDER BY ${eTable}.${sortBy}`;
+            ORDER BY ${sortBy}, ${eTable}."guid"`;
         }
       }
     } else {
@@ -1856,28 +1975,31 @@ export default class PostgreSQLDriver extends NymphDriver {
         let limit = '';
         if ('limit' in options) {
           limit = ` LIMIT ${Math.floor(
-            isNaN(Number(options.limit)) ? 0 : Number(options.limit)
+            isNaN(Number(options.limit)) ? 0 : Number(options.limit),
           )}`;
         }
         let offset = '';
         if ('offset' in options) {
           offset = ` OFFSET ${Math.floor(
-            isNaN(Number(options.offset)) ? 0 : Number(options.offset)
+            isNaN(Number(options.offset)) ? 0 : Number(options.offset),
           )}`;
         }
+        const guidClause = guidSelector
+          ? ` WHERE ${ieTable}."guid"=${guidSelector}`
+          : '';
         if (options.return === 'count') {
           if (limit || offset) {
             query = `SELECT COUNT(${countTable}."guid") AS "count" FROM (
-                SELECT COUNT(${ieTable}."guid") AS "guid"
+                SELECT ${ieTable}."guid" AS "guid"
                 FROM ${PostgreSQLDriver.escape(
-                  `${this.prefix}entities_${etype}`
-                )} ${ieTable}${limit}${offset}
+                  `${this.prefix}entities_${etype}`,
+                )} ${ieTable}${guidClause}${limit}${offset}
               ) ${countTable}`;
           } else {
             query = `SELECT COUNT(${ieTable}."guid") AS "count"
               FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}entities_${etype}`
-              )} ${ieTable}`;
+                `${this.prefix}entities_${etype}`,
+              )} ${ieTable}${guidClause}`;
           }
         } else if (options.return === 'guid') {
           const guidColumn =
@@ -1886,9 +2008,11 @@ export default class PostgreSQLDriver extends NymphDriver {
               : `${ieTable}."guid"`;
           query = `SELECT ${guidColumn} AS "guid"
             FROM ${PostgreSQLDriver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} ${ieTable}
-            ORDER BY ${ieTable}.${sortBy}${limit}${offset}`;
+            ${sortJoinInner}
+            ${guidClause}
+            ORDER BY ${sortByInner}, ${ieTable}."guid"${limit}${offset}`;
         } else {
           if (limit || offset) {
             query = `SELECT
@@ -1898,25 +2022,26 @@ export default class PostgreSQLDriver extends NymphDriver {
                 ${eTable}."mdate",
                 ${dTable}."name",
                 ${dTable}."value",
-                ${cTable}."string",
-                ${cTable}."number"
+                ${dTable}."json",
+                ${dTable}."string",
+                ${dTable}."number"
               FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}entities_${etype}`
+                `${this.prefix}entities_${etype}`,
               )} ${eTable}
               LEFT JOIN ${PostgreSQLDriver.escape(
-                `${this.prefix}data_${etype}`
+                `${this.prefix}data_${etype}`,
               )} ${dTable} ON ${eTable}."guid"=${dTable}."guid"
-              INNER JOIN ${PostgreSQLDriver.escape(
-                `${this.prefix}comparisons_${etype}`
-              )} ${cTable} ON ${dTable}."guid"=${cTable}."guid" AND ${dTable}."name"=${cTable}."name"
+              ${sortJoin}
               INNER JOIN (
                 SELECT ${ieTable}."guid"
                 FROM ${PostgreSQLDriver.escape(
-                  `${this.prefix}entities_${etype}`
+                  `${this.prefix}entities_${etype}`,
                 )} ${ieTable}
-                ORDER BY ${ieTable}.${sortBy}${limit}${offset}
+                ${sortJoinInner}
+                ${guidClause}
+                ORDER BY ${sortByInner}${limit}${offset}
               ) ${fTable} ON ${eTable}."guid"=${fTable}."guid"
-              ORDER BY ${eTable}.${sortBy}`;
+              ORDER BY ${sortBy}, ${eTable}."guid"`;
           } else {
             query = `SELECT
                 encode(${eTable}."guid", 'hex') AS "guid",
@@ -1925,18 +2050,18 @@ export default class PostgreSQLDriver extends NymphDriver {
                 ${eTable}."mdate",
                 ${dTable}."name",
                 ${dTable}."value",
-                ${cTable}."string",
-                ${cTable}."number"
+                ${dTable}."json",
+                ${dTable}."string",
+                ${dTable}."number"
               FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}entities_${etype}`
+                `${this.prefix}entities_${etype}`,
               )} ${eTable}
               LEFT JOIN ${PostgreSQLDriver.escape(
-                `${this.prefix}data_${etype}`
+                `${this.prefix}data_${etype}`,
               )} ${dTable} ON ${eTable}."guid"=${dTable}."guid"
-              INNER JOIN ${PostgreSQLDriver.escape(
-                `${this.prefix}comparisons_${etype}`
-              )} ${cTable} ON ${dTable}."guid"=${cTable}."guid" AND ${dTable}."name"=${cTable}."name"
-              ORDER BY ${eTable}.${sortBy}`;
+              ${sortJoin}
+              ${guidSelector ? `WHERE ${eTable}."guid"=${guidSelector}` : ''}
+              ORDER BY ${sortBy}, ${eTable}."guid"`;
           }
         }
       }
@@ -1956,43 +2081,23 @@ export default class PostgreSQLDriver 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 }).then((val) =>
-      val[Symbol.iterator]()
+    const result = this.queryArray(query, { etypes, params }).then((val) =>
+      val[Symbol.iterator](),
     );
     return {
       result,
     };
   }
 
-  protected performQuerySync(
-    options: Options,
-    formattedSelectors: FormattedSelector[],
-    etype: string
-  ): {
-    result: any;
-  } {
-    const { query, params, etypes } = this.makeEntityQuery(
-      options,
-      formattedSelectors,
-      etype
-    );
-    const result = (this.queryIterSync(query, { etypes, params }) || [])[
-      Symbol.iterator
-    ]();
-    return {
-      result,
-    };
-  }
-
   public async getEntities<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'count' },
     ...selectors: Selector[]
@@ -2004,17 +2109,17 @@ export default class PostgreSQLDriver 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> {
-    const { result: resultPromise, process } = this.getEntitesRowLike<T>(
+  ): Promise<EntityInstanceType<T>[] | string[] | number> {
+    const { result: resultPromise, process } = this.getEntitiesRowLike<T>(
       // @ts-ignore: options is correct here.
       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;
@@ -2023,7 +2128,7 @@ export default class PostgreSQLDriver extends NymphDriver {
       (row) => Number(row.count),
       (row) => row.guid,
       (row) => ({
-        tags: row.tags,
+        tags: row.tags.filter((tag: string) => tag),
         cdate: isNaN(Number(row.cdate)) ? null : Number(row.cdate),
         mdate: isNaN(Number(row.mdate)) ? null : Number(row.mdate),
       }),
@@ -2033,9 +2138,13 @@ export default class PostgreSQLDriver extends NymphDriver {
           row.value === 'N'
             ? JSON.stringify(Number(row.number))
             : row.value === 'S'
-            ? JSON.stringify(row.string)
-            : row.value,
-      })
+              ? JSON.stringify(PostgreSQLDriver.unescapeNulls(row.string))
+              : row.value === 'J'
+                ? PostgreSQLDriver.unescapeNullSequences(
+                    JSON.stringify(row.json),
+                  )
+                : row.value,
+      }),
     );
 
     const result = await resultPromise;
@@ -2046,252 +2155,228 @@ export default class PostgreSQLDriver extends NymphDriver {
     return value;
   }
 
-  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>(
-      // @ts-ignore: options is correct here.
-      options,
-      selectors,
-      (options, formattedSelectors, etype) =>
-        this.performQuerySync(options, formattedSelectors, etype),
-      () => {
-        const next: any = result.next();
-        return next.done ? null : next.value;
-      },
-      () => undefined,
-      (row) => Number(row.count),
-      (row) => row.guid,
-      (row) => ({
-        tags: row.tags,
-        cdate: isNaN(Number(row.cdate)) ? null : Number(row.cdate),
-        mdate: isNaN(Number(row.mdate)) ? null : Number(row.mdate),
-      }),
-      (row) => ({
-        name: row.name,
-        svalue:
-          row.value === 'N'
-            ? JSON.stringify(Number(row.number))
-            : row.value === 'S'
-            ? JSON.stringify(row.string)
-            : row.value,
-      })
-    );
-    const value = process();
-    if (value instanceof Error) {
-      throw value;
-    }
-    return value;
-  }
-
   public async getUID(name: string) {
     if (name == null) {
       throw new InvalidParametersError('Name not given for UID.');
     }
     const result = await this.queryGet(
       `SELECT "cur_uid" FROM ${PostgreSQLDriver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} WHERE "name"=@name;`,
       {
         params: {
           name: name,
         },
-      }
+      },
     );
     return result?.cur_uid == null ? null : Number(result.cur_uid);
   }
 
-  public async import(filename: string) {
+  public async importEntity({
+    guid,
+    cdate,
+    mdate,
+    tags,
+    sdata,
+    etype,
+  }: {
+    guid: string;
+    cdate: number;
+    mdate: number;
+    tags: string[];
+    sdata: SerializedEntityData;
+    etype: string;
+  }) {
     try {
-      const result = await this.importFromFile(
-        filename,
-        async (guid, tags, sdata, etype) => {
-          await this.queryRun(
-            `DELETE FROM ${PostgreSQLDriver.escape(
-              `${this.prefix}entities_${etype}`
-            )} WHERE "guid"=decode(@guid, 'hex');`,
-            {
-              etypes: [etype],
-              params: {
-                guid,
-              },
-            }
-          );
-          await this.queryRun(
+      let promises = [];
+      promises.push(
+        this.queryRun(
+          `DELETE FROM ${PostgreSQLDriver.escape(
+            `${this.prefix}entities_${etype}`,
+          )} WHERE "guid"=decode(@guid, 'hex');`,
+          {
+            etypes: [etype],
+            params: {
+              guid,
+            },
+          },
+        ),
+      );
+      promises.push(
+        this.queryRun(
+          `DELETE FROM ${PostgreSQLDriver.escape(
+            `${this.prefix}data_${etype}`,
+          )} WHERE "guid"=decode(@guid, 'hex');`,
+          {
+            etypes: [etype],
+            params: {
+              guid,
+            },
+          },
+        ),
+      );
+      promises.push(
+        this.queryRun(
+          `DELETE FROM ${PostgreSQLDriver.escape(
+            `${this.prefix}references_${etype}`,
+          )} WHERE "guid"=decode(@guid, 'hex');`,
+          {
+            etypes: [etype],
+            params: {
+              guid,
+            },
+          },
+        ),
+      );
+      promises.push(
+        this.queryRun(
+          `DELETE FROM ${PostgreSQLDriver.escape(
+            `${this.prefix}uniques_${etype}`,
+          )} WHERE "guid"=decode(@guid, 'hex');`,
+          {
+            etypes: [etype],
+            params: {
+              guid,
+            },
+          },
+        ),
+      );
+      await Promise.all(promises);
+      promises = [];
+      await this.queryRun(
+        `INSERT INTO ${PostgreSQLDriver.escape(
+          `${this.prefix}entities_${etype}`,
+        )} ("guid", "tags", "cdate", "mdate") VALUES (decode(@guid, 'hex'), @tags, @cdate, @mdate);`,
+        {
+          etypes: [etype],
+          params: {
+            guid,
+            tags,
+            cdate: isNaN(cdate) ? null : cdate,
+            mdate: isNaN(mdate) ? null : 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'
+              : 'J';
+        const jsonValue =
+          storageValue === 'J'
+            ? PostgreSQLDriver.escapeNullSequences(value)
+            : null;
+        promises.push(
+          this.queryRun(
             `INSERT INTO ${PostgreSQLDriver.escape(
-              `${this.prefix}entities_${etype}`
-            )} ("guid", "tags", "cdate", "mdate") VALUES (decode(@guid, 'hex'), @tags, @cdate, @mdate);`,
+              `${this.prefix}data_${etype}`,
+            )} ("guid", "name", "value", "json", "string", "number", "truthy") VALUES (decode(@guid, 'hex'), @name, @storageValue, @jsonValue, @string, @number, @truthy);`,
             {
               etypes: [etype],
               params: {
                 guid,
-                tags,
-                cdate: isNaN(Number(JSON.parse(sdata.cdate)))
-                  ? null
-                  : Number(JSON.parse(sdata.cdate)),
-                mdate: isNaN(Number(JSON.parse(sdata.mdate)))
-                  ? null
-                  : Number(JSON.parse(sdata.mdate)),
+                name,
+                storageValue,
+                jsonValue,
+                string:
+                  storageValue === 'J'
+                    ? null
+                    : PostgreSQLDriver.escapeNulls(`${uvalue}`),
+                number: isNaN(Number(uvalue)) ? null : Number(uvalue),
+                truthy: !!uvalue,
               },
-            }
-          );
-          const promises = [];
-          promises.push(
-            this.queryRun(
-              `DELETE FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}data_${etype}`
-              )} WHERE "guid"=decode(@guid, 'hex');`,
-              {
-                etypes: [etype],
-                params: {
-                  guid,
-                },
-              }
-            )
-          );
-          promises.push(
-            this.queryRun(
-              `DELETE FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}comparisons_${etype}`
-              )} WHERE "guid"=decode(@guid, 'hex');`,
-              {
-                etypes: [etype],
-                params: {
-                  guid,
-                },
-              }
-            )
-          );
+            },
+          ),
+        );
+        const references = this.findReferences(value);
+        for (const reference of references) {
           promises.push(
             this.queryRun(
-              `DELETE FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}references_${etype}`
-              )} WHERE "guid"=decode(@guid, 'hex');`,
+              `INSERT INTO ${PostgreSQLDriver.escape(
+                `${this.prefix}references_${etype}`,
+              )} ("guid", "name", "reference") VALUES (decode(@guid, 'hex'), @name, decode(@reference, 'hex'));`,
               {
                 etypes: [etype],
                 params: {
                   guid,
+                  name,
+                  reference,
                 },
-              }
-            )
-          );
-          await Promise.all(promises);
-          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;
-            const promises = [];
-            promises.push(
-              this.queryRun(
-                `INSERT INTO ${PostgreSQLDriver.escape(
-                  `${this.prefix}data_${etype}`
-                )} ("guid", "name", "value") VALUES (decode(@guid, 'hex'), @name, @storageValue);`,
-                {
-                  etypes: [etype],
-                  params: {
-                    guid,
-                    name,
-                    storageValue,
-                  },
-                }
-              )
-            );
-            promises.push(
-              this.queryRun(
-                `INSERT INTO ${PostgreSQLDriver.escape(
-                  `${this.prefix}comparisons_${etype}`
-                )} ("guid", "name", "truthy", "string", "number") VALUES (decode(@guid, 'hex'), @name, @truthy, @string, @number);`,
-                {
-                  etypes: [etype],
-                  params: {
-                    guid,
-                    name,
-                    truthy: !!uvalue,
-                    string: `${uvalue}`,
-                    number: isNaN(Number(uvalue)) ? null : Number(uvalue),
-                  },
-                }
-              )
-            );
-            const references = this.findReferences(value);
-            for (const reference of references) {
-              promises.push(
-                this.queryRun(
-                  `INSERT INTO ${PostgreSQLDriver.escape(
-                    `${this.prefix}references_${etype}`
-                  )} ("guid", "name", "reference") VALUES (decode(@guid, 'hex'), @name, decode(@reference, 'hex'));`,
-                  {
-                    etypes: [etype],
-                    params: {
-                      guid,
-                      name,
-                      reference,
-                    },
-                  }
-                )
-              );
-            }
-          }
-          await Promise.all(promises);
-        },
-        async (name, curUid) => {
-          await this.queryRun(
-            `DELETE FROM ${PostgreSQLDriver.escape(
-              `${this.prefix}uids`
-            )} WHERE "name"=@name;`,
-            {
-              params: {
-                name,
               },
-            }
+            ),
           );
-          await this.queryRun(
+        }
+      }
+      const uniques = await this.nymph
+        .getEntityClassByEtype(etype)
+        .getUniques({ guid, cdate, mdate, tags, data: {}, sdata });
+      for (const unique of uniques) {
+        promises.push(
+          this.queryRun(
             `INSERT INTO ${PostgreSQLDriver.escape(
-              `${this.prefix}uids`
-            )} ("name", "cur_uid") VALUES (@name, @curUid);`,
+              `${this.prefix}uniques_${etype}`,
+            )} ("guid", "unique") VALUES (decode(@guid, 'hex'), @unique);`,
             {
+              etypes: [etype],
               params: {
-                name,
-                curUid,
+                guid,
+                unique,
               },
+            },
+          ).catch((e: any) => {
+            if (e instanceof EntityUniqueConstraintError) {
+              this.nymph.config.debugError(
+                'postgresql',
+                `Import entity unique constraint violation for GUID "${guid}" on etype "${etype}": "${unique}"`,
+              );
             }
-          );
+            return e;
+          }),
+        );
+      }
+      await Promise.all(promises);
+    } catch (e: any) {
+      this.nymph.config.debugError('postgresql', `Import entity error: "${e}"`);
+      throw e;
+    }
+  }
+
+  public async importUID({ name, value }: { name: string; value: number }) {
+    try {
+      await this.internalTransaction(`nymph-import-uid-${name}`);
+      await this.queryRun(
+        `DELETE FROM ${PostgreSQLDriver.escape(
+          `${this.prefix}uids`,
+        )} WHERE "name"=@name;`,
+        {
+          params: {
+            name,
+          },
         },
-        async () => {
-          await this.internalTransaction('nymph-import');
+      );
+      await this.queryRun(
+        `INSERT INTO ${PostgreSQLDriver.escape(
+          `${this.prefix}uids`,
+        )} ("name", "cur_uid") VALUES (@name, @value);`,
+        {
+          params: {
+            name,
+            value,
+          },
         },
-        async () => {
-          await this.commit('nymph-import');
-        }
       );
-
-      return result;
+      await this.commit(`nymph-import-uid-${name}`);
     } catch (e: any) {
-      await this.rollback('nymph-import');
-      return false;
+      this.nymph.config.debugError('postgresql', `Import UID error: "${e}"`);
+      await this.rollback(`nymph-import-uid-${name}`);
+      throw e;
     }
   }
 
@@ -2300,52 +2385,54 @@ export default class PostgreSQLDriver extends NymphDriver {
       throw new InvalidParametersError('Name not given for UID.');
     }
     await this.internalTransaction('nymph-newuid');
+    let curUid: number | undefined = undefined;
     try {
       const lock = await this.queryGet(
         `SELECT "cur_uid" FROM ${PostgreSQLDriver.escape(
-          `${this.prefix}uids`
+          `${this.prefix}uids`,
         )} WHERE "name"=@name FOR UPDATE;`,
         {
           params: {
             name,
           },
-        }
+        },
       );
-      let curUid: number | undefined =
-        lock?.cur_uid == null ? undefined : Number(lock.cur_uid);
+      curUid = lock?.cur_uid == null ? undefined : Number(lock.cur_uid);
       if (curUid == null) {
         curUid = 1;
         await this.queryRun(
           `INSERT INTO ${PostgreSQLDriver.escape(
-            `${this.prefix}uids`
+            `${this.prefix}uids`,
           )} ("name", "cur_uid") VALUES (@name, @curUid);`,
           {
             params: {
               name,
               curUid,
             },
-          }
+          },
         );
       } else {
         curUid++;
         await this.queryRun(
           `UPDATE ${PostgreSQLDriver.escape(
-            `${this.prefix}uids`
+            `${this.prefix}uids`,
           )} SET "cur_uid"=@curUid WHERE "name"=@name;`,
           {
             params: {
               name,
               curUid,
             },
-          }
+          },
         );
       }
-      await this.commit('nymph-newuid');
-      return curUid;
     } catch (e: any) {
+      this.nymph.config.debugError('postgresql', `New UID error: "${e}"`);
       await this.rollback('nymph-newuid');
       throw e;
     }
+
+    await this.commit('nymph-newuid');
+    return curUid;
   }
 
   public async renameUID(oldName: string, newName: string) {
@@ -2354,14 +2441,14 @@ export default class PostgreSQLDriver extends NymphDriver {
     }
     await this.queryRun(
       `UPDATE ${PostgreSQLDriver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} SET "name"=@newName WHERE "name"=@oldName;`,
       {
         params: {
           newName,
           oldName,
         },
-      }
+      },
     );
     return true;
   }
@@ -2369,7 +2456,7 @@ export default class PostgreSQLDriver extends NymphDriver {
   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.transaction || this.transaction.count === 0) {
@@ -2377,7 +2464,7 @@ export default class PostgreSQLDriver extends NymphDriver {
       return true;
     }
     await this.queryRun(
-      `ROLLBACK TO SAVEPOINT ${PostgreSQLDriver.escape(name)};`
+      `ROLLBACK TO SAVEPOINT ${PostgreSQLDriver.escape(name)};`,
     );
     this.transaction.count--;
     if (this.transaction.count === 0) {
@@ -2394,12 +2481,13 @@ export default class PostgreSQLDriver extends NymphDriver {
       guid: string,
       data: EntityData,
       sdata: SerializedEntityData,
-      etype: string
+      uniques: string[],
+      etype: string,
     ) => {
       const runInsertQuery = async (
         name: string,
         value: any,
-        svalue: string
+        svalue: string,
       ) => {
         if (value === undefined) {
           return;
@@ -2408,47 +2496,41 @@ export default class PostgreSQLDriver extends NymphDriver {
           typeof value === 'number'
             ? 'N'
             : typeof value === 'string'
-            ? 'S'
-            : svalue;
+              ? 'S'
+              : 'J';
+        const jsonValue =
+          storageValue === 'J'
+            ? PostgreSQLDriver.escapeNullSequences(svalue)
+            : null;
         const promises = [];
         promises.push(
           this.queryRun(
             `INSERT INTO ${PostgreSQLDriver.escape(
-              `${this.prefix}data_${etype}`
-            )} ("guid", "name", "value") VALUES (decode(@guid, 'hex'), @name, @storageValue);`,
+              `${this.prefix}data_${etype}`,
+            )} ("guid", "name", "value", "json", "string", "number", "truthy") VALUES (decode(@guid, 'hex'), @name, @storageValue, @jsonValue, @string, @number, @truthy);`,
             {
               etypes: [etype],
               params: {
                 guid,
                 name,
                 storageValue,
-              },
-            }
-          )
-        );
-        promises.push(
-          this.queryRun(
-            `INSERT INTO ${PostgreSQLDriver.escape(
-              `${this.prefix}comparisons_${etype}`
-            )} ("guid", "name", "truthy", "string", "number") VALUES (decode(@guid, 'hex'), @name, @truthy, @string, @number);`,
-            {
-              etypes: [etype],
-              params: {
-                guid,
-                name,
-                truthy: !!value,
-                string: `${value}`,
+                jsonValue,
+                string:
+                  storageValue === 'J'
+                    ? null
+                    : PostgreSQLDriver.escapeNulls(`${value}`),
                 number: isNaN(Number(value)) ? null : Number(value),
+                truthy: !!value,
               },
-            }
-          )
+            },
+          ),
         );
         const references = this.findReferences(svalue);
         for (const reference of references) {
           promises.push(
             this.queryRun(
               `INSERT INTO ${PostgreSQLDriver.escape(
-                `${this.prefix}references_${etype}`
+                `${this.prefix}references_${etype}`,
               )} ("guid", "name", "reference") VALUES (decode(@guid, 'hex'), @name, decode(@reference, 'hex'));`,
               {
                 etypes: [etype],
@@ -2457,12 +2539,36 @@ export default class PostgreSQLDriver extends NymphDriver {
                   name,
                   reference,
                 },
-              }
-            )
+              },
+            ),
           );
         }
         await Promise.all(promises);
       };
+      for (const unique of uniques) {
+        try {
+          await this.queryRun(
+            `INSERT INTO ${PostgreSQLDriver.escape(
+              `${this.prefix}uniques_${etype}`,
+            )} ("guid", "unique") VALUES (decode(@guid, 'hex'), @unique);`,
+            {
+              etypes: [etype],
+              params: {
+                guid,
+                unique,
+              },
+            },
+          );
+        } catch (e: any) {
+          if (e instanceof EntityUniqueConstraintError) {
+            this.nymph.config.debugError(
+              'postgresql',
+              `Save entity unique constraint violation for GUID "${guid}" on etype "${etype}": "${unique}"`,
+            );
+          }
+          throw e;
+        }
+      }
       for (const name in data) {
         await runInsertQuery(name, data[name], JSON.stringify(data[name]));
       }
@@ -2470,13 +2576,20 @@ export default class PostgreSQLDriver extends NymphDriver {
         await runInsertQuery(name, JSON.parse(sdata[name]), sdata[name]);
       }
     };
+    let inTransaction = false;
     try {
       const result = await 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;
+          }
           await this.queryRun(
             `INSERT INTO ${PostgreSQLDriver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} ("guid", "tags", "cdate", "mdate") VALUES (decode(@guid, 'hex'), @tags, @cdate, @cdate);`,
             {
               etypes: [etype],
@@ -2485,69 +2598,75 @@ export default class PostgreSQLDriver extends NymphDriver {
                 tags,
                 cdate,
               },
-            }
+            },
           );
-          await insertData(guid, data, sdata, etype);
+          await 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 promises = [];
           promises.push(
             this.queryRun(
               `SELECT 1 FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}entities_${etype}`
+                `${this.prefix}entities_${etype}`,
               )} WHERE "guid"=decode(@guid, 'hex') FOR UPDATE;`,
               {
                 etypes: [etype],
                 params: {
                   guid,
                 },
-              }
-            )
+              },
+            ),
           );
           promises.push(
             this.queryRun(
               `SELECT 1 FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}data_${etype}`
+                `${this.prefix}data_${etype}`,
               )} WHERE "guid"=decode(@guid, 'hex') FOR UPDATE;`,
               {
                 etypes: [etype],
                 params: {
                   guid,
                 },
-              }
-            )
+              },
+            ),
           );
           promises.push(
             this.queryRun(
               `SELECT 1 FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}comparisons_${etype}`
+                `${this.prefix}references_${etype}`,
               )} WHERE "guid"=decode(@guid, 'hex') FOR UPDATE;`,
               {
                 etypes: [etype],
                 params: {
                   guid,
                 },
-              }
-            )
+              },
+            ),
           );
           promises.push(
             this.queryRun(
               `SELECT 1 FROM ${PostgreSQLDriver.escape(
-                `${this.prefix}references_${etype}`
+                `${this.prefix}uniques_${etype}`,
               )} WHERE "guid"=decode(@guid, 'hex') FOR UPDATE;`,
               {
                 etypes: [etype],
                 params: {
                   guid,
                 },
-              }
-            )
+              },
+            ),
           );
           await Promise.all(promises);
           const info = await this.queryRun(
             `UPDATE ${PostgreSQLDriver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} SET "tags"=@tags, "mdate"=@mdate WHERE "guid"=decode(@guid, 'hex') AND "mdate" <= @emdate;`,
             {
               etypes: [etype],
@@ -2557,7 +2676,7 @@ export default class PostgreSQLDriver extends NymphDriver {
                 guid,
                 emdate: isNaN(Number(entity.mdate)) ? 0 : Number(entity.mdate),
               },
-            }
+            },
           );
           let success = false;
           if (info.rowCount === 1) {
@@ -2565,64 +2684,71 @@ export default class PostgreSQLDriver extends NymphDriver {
             promises.push(
               this.queryRun(
                 `DELETE FROM ${PostgreSQLDriver.escape(
-                  `${this.prefix}data_${etype}`
+                  `${this.prefix}data_${etype}`,
                 )} WHERE "guid"=decode(@guid, 'hex');`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                   },
-                }
-              )
+                },
+              ),
             );
             promises.push(
               this.queryRun(
                 `DELETE FROM ${PostgreSQLDriver.escape(
-                  `${this.prefix}comparisons_${etype}`
+                  `${this.prefix}references_${etype}`,
                 )} WHERE "guid"=decode(@guid, 'hex');`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                   },
-                }
-              )
+                },
+              ),
             );
             promises.push(
               this.queryRun(
                 `DELETE FROM ${PostgreSQLDriver.escape(
-                  `${this.prefix}references_${etype}`
+                  `${this.prefix}uniques_${etype}`,
                 )} WHERE "guid"=decode(@guid, 'hex');`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                   },
-                }
-              )
+                },
+              ),
             );
             await Promise.all(promises);
-            await insertData(guid, data, sdata, etype);
+            await insertData(guid, data, sdata, uniques, etype);
             success = true;
           }
           return success;
         },
         async () => {
           await this.internalTransaction('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;
-        }
+        },
       );
 
       return result;
     } catch (e: any) {
-      await this.rollback('nymph-save');
+      this.nymph.config.debugError('postgresql', `Save entity error: "${e}"`);
+      if (inTransaction) {
+        await this.rollback('nymph-save');
+      }
       throw e;
     }
   }
@@ -2635,38 +2761,39 @@ export default class PostgreSQLDriver extends NymphDriver {
     try {
       await this.queryRun(
         `DELETE FROM ${PostgreSQLDriver.escape(
-          `${this.prefix}uids`
+          `${this.prefix}uids`,
         )} WHERE "name"=@name;`,
         {
           params: {
             name,
             curUid,
           },
-        }
+        },
       );
       await this.queryRun(
         `INSERT INTO ${PostgreSQLDriver.escape(
-          `${this.prefix}uids`
+          `${this.prefix}uids`,
         )} ("name", "cur_uid") VALUES (@name, @curUid);`,
         {
           params: {
             name,
             curUid,
           },
-        }
+        },
       );
-      await this.commit('nymph-setuid');
-      return true;
     } catch (e: any) {
       await this.rollback('nymph-setuid');
       throw e;
     }
+
+    await this.commit('nymph-setuid');
+    return true;
   }
 
-  private async internalTransaction(name: string) {
+  protected async internalTransaction(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.',
       );
     }
 
@@ -2688,7 +2815,7 @@ export default class PostgreSQLDriver extends NymphDriver {
   }
 
   public async startTransaction(name: string) {
-    const inTransaction = this.inTransaction();
+    const inTransaction = await this.inTransaction();
     const transaction = await this.internalTransaction(name);
     if (!inTransaction) {
       this.transaction = null;
@@ -2699,4 +2826,29 @@ export default class PostgreSQLDriver extends NymphDriver {
 
     return nymph;
   }
+
+  public async needsMigration(): Promise<boolean> {
+    const table = await this.queryGet(
+      'SELECT "table_name" AS "table_name" FROM "information_schema"."tables" WHERE "table_catalog"=@db AND "table_schema"=\'public\' AND "table_name" LIKE @prefix LIMIT 1;',
+      {
+        params: {
+          db: this.config.database,
+          prefix: this.prefix + 'data_' + '%',
+        },
+      },
+    );
+    if (table?.table_name) {
+      const result = await this.queryGet(
+        'SELECT 1 AS "exists" FROM "information_schema"."columns" WHERE "table_catalog"=@db AND "table_schema"=\'public\' AND "table_name"=@table AND "column_name"=\'json\';',
+        {
+          params: {
+            db: this.config.database,
+            table: table.table_name,
+          },
+        },
+      );
+      return !result?.exists;
+    }
+    return false;
+  }
 }