@nymphjs/driver-mysql 1.0.0-beta.13 → 1.0.0-beta.130

package/src/MySQLDriver.ts

@@ -1,21 +1,30 @@
-import cp from 'child_process';
-// @ts-ignore: types are wonky with @vlasky/mysql.
-import { default as MySQLType } from '@types/mysql';
-// @ts-ignore: replace with mysql once https://github.com/mysqljs/mysql/pull/2233 is merged.
-import vlaskyMysql from '@vlasky/mysql';
+import { Pool, PoolOptions, PoolConnection } from 'mysql2';
+import mysql from 'mysql2';
+import SqlString from 'sqlstring';
+import type {
+  SearchTerm,
+  SearchOrTerm,
+  SearchNotTerm,
+  SearchSeriesTerm,
+} from '@sciactive/tokenizer';
 import {
   NymphDriver,
-  EntityConstructor,
-  EntityData,
-  EntityInterface,
-  SerializedEntityData,
+  type EntityConstructor,
+  type EntityData,
+  type EntityObjectType,
+  type EntityInterface,
+  type EntityInstanceType,
+  type SerializedEntityData,
+  type FormattedSelector,
+  type Options,
+  type Selector,
+  EntityConflictError,
+  EntityInvalidDataError,
+  EntityUniqueConstraintError,
   InvalidParametersError,
   NotConfiguredError,
   QueryFailedError,
   UnableToConnectError,
-  FormattedSelector,
-  Options,
-  Selector,
   xor,
 } from '@nymphjs/nymph';
 import { makeTableSuffix } from '@nymphjs/guid';
@@ -23,29 +32,28 @@ import { makeTableSuffix } from '@nymphjs/guid';
 import {
   MySQLDriverConfig,
   MySQLDriverConfigDefaults as defaults,
-} from './conf';
+} from './conf/index.js';
 
 type MySQLDriverTransaction = {
-  connection: MySQLType.PoolConnection | null;
+  connection: PoolConnection | null;
   count: number;
+  latestPromise: Promise<any>;
 };
 
-const mysql = vlaskyMysql as typeof MySQLType;
-
 /**
  * The MySQL Nymph database driver.
  */
 export default class MySQLDriver extends NymphDriver {
   public config: MySQLDriverConfig;
-  private mysqlConfig: MySQLType.PoolConfig;
+  private mysqlConfig: PoolOptions;
   protected prefix: string;
   protected connected: boolean = false;
   // @ts-ignore: this is assigned in connect(), which is called by the constructor.
-  protected link: MySQLType.Pool;
+  protected link: Pool;
   protected transaction: MySQLDriverTransaction | null = null;
 
   static escape(input: string) {
-    return mysql.escapeId(input);
+    return SqlString.escapeId(input, true);
   }
 
   static escapeValue(input: string) {
@@ -54,8 +62,8 @@ export default class MySQLDriver extends NymphDriver {
 
   constructor(
     config: Partial<MySQLDriverConfig>,
-    link?: MySQLType.Pool,
-    transaction?: MySQLDriverTransaction
+    link?: Pool,
+    transaction?: MySQLDriverTransaction,
   ) {
     super();
     this.config = { ...defaults, ...config };
@@ -90,16 +98,16 @@ export default class MySQLDriver extends NymphDriver {
     return new MySQLDriver(
       this.config,
       this.link,
-      this.transaction ?? undefined
+      this.transaction ?? undefined,
     );
   }
 
-  private getConnection(): Promise<MySQLType.PoolConnection> {
+  private getConnection(): Promise<PoolConnection> {
     if (this.transaction != null && this.transaction.connection != null) {
       return Promise.resolve(this.transaction.connection);
     }
     return new Promise((resolve, reject) =>
-      this.link.getConnection((err, con) => (err ? reject(err) : resolve(con)))
+      this.link.getConnection((err, con) => (err ? reject(err) : resolve(con))),
     );
   }
 
@@ -112,16 +120,11 @@ export default class MySQLDriver extends NymphDriver {
     // If we think we're connected, try pinging the server.
     try {
       if (this.connected) {
-        const connection: MySQLType.PoolConnection = await new Promise(
+        const connection: PoolConnection = await new Promise(
           (resolve, reject) =>
             this.link.getConnection((err, con) =>
-              err ? reject(err) : resolve(con)
-            )
-        );
-        await new Promise((resolve) =>
-          connection.ping(() => {
-            resolve(0);
-          })
+              err ? reject(err) : resolve(con),
+            ),
         );
         connection.release();
       }
@@ -132,7 +135,10 @@ export default class MySQLDriver extends NymphDriver {
     // Connecting, selecting database
     if (!this.connected) {
       try {
-        this.link = mysql.createPool(this.mysqlConfig);
+        this.link = mysql.createPool({
+          ...this.mysqlConfig,
+          charset: 'utf8mb4_bin',
+        });
         this.connected = true;
       } catch (e: any) {
         if (
@@ -142,7 +148,7 @@ export default class MySQLDriver extends NymphDriver {
           this.mysqlConfig.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);
@@ -166,6 +172,9 @@ export default class MySQLDriver extends NymphDriver {
   }
 
   public async inTransaction() {
+    if (this.transaction && this.transaction.count === 0) {
+      this.transaction = null;
+    }
     return !!this.transaction;
   }
 
@@ -178,106 +187,271 @@ export default class MySQLDriver extends NymphDriver {
     return this.connected;
   }
 
-  /**
-   * Create entity tables in the database.
-   *
-   * @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) {
-    this.queryRunSync('SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";');
-    let foreignKeyDataTableGuid = '';
-    let foreignKeyDataComparisonsTableGuid = '';
-    let foreignKeyReferencesTableGuid = '';
-    if (this.config.foreignKeys) {
-      foreignKeyDataTableGuid = ` REFERENCES ${MySQLDriver.escape(
-        `${this.prefix}entities_${etype}`
-      )}(\`guid\`) ON DELETE CASCADE`;
-      foreignKeyDataComparisonsTableGuid = ` REFERENCES ${MySQLDriver.escape(
-        `${this.prefix}entities_${etype}`
-      )}(\`guid\`) ON DELETE CASCADE`;
-      foreignKeyReferencesTableGuid = ` REFERENCES ${MySQLDriver.escape(
-        `${this.prefix}entities_${etype}`
-      )}(\`guid\`) ON DELETE CASCADE`;
-    }
-    if (etype != null) {
-      // Create the entity table.
-      this.queryRunSync(
-        `CREATE TABLE IF NOT EXISTS ${MySQLDriver.escape(
-          `${this.prefix}entities_${etype}`
-        )} (
+  private async createEntitiesTable(etype: string) {
+    // Create the entity table.
+    await this.queryRun(
+      `CREATE TABLE IF NOT EXISTS ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} (
           \`guid\` BINARY(12) NOT NULL,
           \`tags\` LONGTEXT,
           \`cdate\` DOUBLE PRECISION NOT NULL,
           \`mdate\` DOUBLE PRECISION NOT NULL,
+          \`user\` BINARY(12),
+          \`group\` BINARY(12),
+          \`acUser\` TINYINT UNSIGNED,
+          \`acGroup\` TINYINT UNSIGNED,
+          \`acOther\` TINYINT UNSIGNED,
+          \`acRead\` LONGTEXT,
+          \`acWrite\` LONGTEXT,
+          \`acFull\` LONGTEXT,
           PRIMARY KEY (\`guid\`),
+          INDEX \`id_guid\` USING HASH (\`guid\`),
           INDEX \`id_cdate\` USING BTREE (\`cdate\`),
           INDEX \`id_mdate\` USING BTREE (\`mdate\`),
-          FULLTEXT \`id_tags\` (\`tags\`)
-        ) ENGINE ${this.config.engine}
-        CHARACTER SET utf8 COLLATE utf8_bin;`
-      );
-      // Create the data table.
-      this.queryRunSync(
-        `CREATE TABLE IF NOT EXISTS ${MySQLDriver.escape(
-          `${this.prefix}data_${etype}`
-        )} (
-          \`guid\` BINARY(12) NOT NULL${foreignKeyDataTableGuid},
-          \`name\` TEXT NOT NULL,
-          \`value\` LONGTEXT NOT NULL,
-          PRIMARY KEY (\`guid\`,\`name\`(255)),
-          INDEX \`id_name\` USING HASH (\`name\`(255)),
-          INDEX \`id_name_value\` USING BTREE (\`name\`(255), \`value\`(512))
+          FULLTEXT \`id_tags\` (\`tags\`),
+          INDEX \`id_user_acUser\` USING BTREE (\`user\`, \`acUser\`),
+          INDEX \`id_group_acGroup\` USING BTREE (\`group\`, \`acGroup\`),
+          INDEX \`id_acUser\` USING BTREE (\`acUser\`),
+          INDEX \`id_acGroup\` USING BTREE (\`acGroup\`),
+          INDEX \`id_acOther\` USING BTREE (\`acOther\`),
+          FULLTEXT \`id_acRead\` (\`acRead\`),
+          FULLTEXT \`id_acWrite\` (\`acWrite\`),
+          FULLTEXT \`id_acFull\` (\`acFull\`)
         ) ENGINE ${this.config.engine}
-        CHARACTER SET utf8 COLLATE utf8_bin;`
-      );
-      // Create the data comparisons table.
-      this.queryRunSync(
-        `CREATE TABLE IF NOT EXISTS ${MySQLDriver.escape(
-          `${this.prefix}comparisons_${etype}`
-        )} (
-          \`guid\` BINARY(12) NOT NULL${foreignKeyDataComparisonsTableGuid},
+        CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;`,
+    );
+  }
+
+  private async addTilmeldColumnsAndIndexes(etype: string) {
+    await this.queryRun(
+      `ALTER TABLE ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} ADD COLUMN \`user\` BINARY(12);`,
+    );
+    await this.queryRun(
+      `ALTER TABLE ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} ADD COLUMN \`group\` BINARY(12);`,
+    );
+    await this.queryRun(
+      `ALTER TABLE ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} ADD COLUMN \`acUser\` TINYINT UNSIGNED;`,
+    );
+    await this.queryRun(
+      `ALTER TABLE ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} ADD COLUMN \`acGroup\` TINYINT UNSIGNED;`,
+    );
+    await this.queryRun(
+      `ALTER TABLE ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} ADD COLUMN \`acOther\` TINYINT UNSIGNED;`,
+    );
+    await this.queryRun(
+      `ALTER TABLE ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} ADD COLUMN \`acRead\` LONGTEXT;`,
+    );
+    await this.queryRun(
+      `ALTER TABLE ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} ADD COLUMN \`acWrite\` LONGTEXT;`,
+    );
+    await this.queryRun(
+      `ALTER TABLE ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} ADD COLUMN \`acFull\` LONGTEXT;`,
+    );
+    await this.createEntitiesTilmeldIndexes(etype);
+  }
+
+  private async createEntitiesTilmeldIndexes(etype: string) {
+    await this.queryRun(
+      `CREATE INDEX \`id_user_acUser\` ON ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} (\`user\`, \`acUser\`) USING BTREE;`,
+    );
+    await this.queryRun(
+      `CREATE INDEX \`id_group_acGroup\` ON ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} (\`group\`, \`acGroup\`) USING BTREE;`,
+    );
+    await this.queryRun(
+      `CREATE INDEX \`id_acUser\` ON ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} (\`acUser\`) USING BTREE;`,
+    );
+    await this.queryRun(
+      `CREATE INDEX \`id_acGroup\` ON ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} (\`acGroup\`) USING BTREE;`,
+    );
+    await this.queryRun(
+      `CREATE INDEX \`id_acOther\` ON ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} (\`acOther\`) USING BTREE;`,
+    );
+    await this.queryRun(
+      `CREATE FULLTEXT INDEX \`id_acRead\` ON ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} (\`acRead\`);`,
+    );
+    await this.queryRun(
+      `CREATE FULLTEXT INDEX \`id_acWrite\` ON ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} (\`acWrite\`);`,
+    );
+    await this.queryRun(
+      `CREATE FULLTEXT INDEX \`id_acFull\` ON ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )} (\`acFull\`);`,
+    );
+  }
+
+  private async createDataTable(etype: string) {
+    let foreignKey = '';
+    if (this.config.foreignKeys) {
+      foreignKey = ` REFERENCES ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )}(\`guid\`) ON DELETE CASCADE`;
+    }
+    // Create the data table.
+    await this.queryRun(
+      `CREATE TABLE IF NOT EXISTS ${MySQLDriver.escape(
+        `${this.prefix}data_${etype}`,
+      )} (
+          \`guid\` BINARY(12) NOT NULL${foreignKey},
           \`name\` TEXT NOT NULL,
-          \`truthy\` BOOLEAN,
+          \`value\` CHAR(1) NOT NULL,
+          \`json\` JSON,
           \`string\` LONGTEXT,
           \`number\` DOUBLE,
+          \`truthy\` BOOLEAN,
           PRIMARY KEY (\`guid\`, \`name\`(255)),
-          INDEX \`id_name\` USING HASH (\`name\`(255))
+          INDEX \`id_name_guid\` USING BTREE (\`name\`(255), \`guid\`),
+          INDEX \`id_name_string_guid\` USING BTREE (\`name\`(255), \`string\`(500), \`guid\`),
+          INDEX \`id_name_number_guid\` USING BTREE (\`name\`(255), \`number\`, \`guid\`),
+          INDEX \`id_name_truthy_guid\` USING BTREE (\`name\`(255), \`truthy\`, \`guid\`),
+          INDEX \`id_name_json_guid\` USING BTREE (\`name\`(255), (CAST(\`json\` AS CHAR(500)) COLLATE utf8mb4_bin), \`guid\`)
         ) ENGINE ${this.config.engine}
-        CHARACTER SET utf8 COLLATE utf8_bin;`
-      );
-      // Create the references table.
-      this.queryRunSync(
-        `CREATE TABLE IF NOT EXISTS ${MySQLDriver.escape(
-          `${this.prefix}references_${etype}`
-        )} (
-          \`guid\` BINARY(12) NOT NULL${foreignKeyReferencesTableGuid},
+        CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;`,
+    );
+  }
+
+  private async createReferencesTable(etype: string) {
+    let foreignKey = '';
+    if (this.config.foreignKeys) {
+      foreignKey = ` REFERENCES ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )}(\`guid\`) ON DELETE CASCADE`;
+    }
+    // Create the references table.
+    await this.queryRun(
+      `CREATE TABLE IF NOT EXISTS ${MySQLDriver.escape(
+        `${this.prefix}references_${etype}`,
+      )} (
+          \`guid\` BINARY(12) NOT NULL${foreignKey},
           \`name\` TEXT NOT NULL,
           \`reference\` BINARY(12) NOT NULL,
           PRIMARY KEY (\`guid\`, \`name\`(255), \`reference\`),
-          INDEX \`id_name_reference\` USING BTREE (\`name\`(255), \`reference\`)
+          INDEX \`id_name_reference_guid\` USING HASH (\`name\`(255), \`reference\`, \`guid\`)
         ) ENGINE ${this.config.engine}
-        CHARACTER SET utf8 COLLATE utf8_bin;`
-      );
+        CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;`,
+    );
+  }
+
+  private async createTokensTable(etype: string) {
+    let foreignKey = '';
+    if (this.config.foreignKeys) {
+      foreignKey = ` REFERENCES ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )}(\`guid\`) ON DELETE CASCADE`;
+    }
+    // Create the tokens table.
+    await this.queryRun(
+      `CREATE TABLE IF NOT EXISTS ${MySQLDriver.escape(
+        `${this.prefix}tokens_${etype}`,
+      )} (
+          \`guid\` BINARY(12) NOT NULL${foreignKey},
+          \`name\` TEXT NOT NULL,
+          \`token\` INT NOT NULL,
+          \`position\` INT UNSIGNED NOT NULL,
+          \`stem\` BOOLEAN NOT NULL,
+          PRIMARY KEY (\`guid\`, \`name\`(255), \`token\`, \`position\`),
+          INDEX \`id_name_token_guid\` USING btree (\`name\`(255), \`token\`, \`guid\`)
+        ) ENGINE ${this.config.engine}
+        CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;`,
+    );
+  }
+
+  private async createUniquesTable(etype: string) {
+    let foreignKey = '';
+    if (this.config.foreignKeys) {
+      foreignKey = ` REFERENCES ${MySQLDriver.escape(
+        `${this.prefix}entities_${etype}`,
+      )}(\`guid\`) ON DELETE CASCADE`;
+    }
+    // Create the unique strings table.
+    // 255 key is max length for charset UTF8.
+    await this.queryRun(
+      `CREATE TABLE IF NOT EXISTS ${MySQLDriver.escape(
+        `${this.prefix}uniques_${etype}`,
+      )} (
+          \`guid\` BINARY(12) NOT NULL${foreignKey},
+          \`unique\` TEXT NOT NULL,
+          PRIMARY KEY (\`guid\`, \`unique\`(255)),
+          INDEX \`id_guid\` USING HASH (\`guid\`),
+          CONSTRAINT \`uc_unique\` UNIQUE (\`unique\`(255))
+        ) ENGINE ${this.config.engine}
+        CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;`,
+    );
+  }
+
+  /**
+   * Create entity tables in the database.
+   *
+   * @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 async createTables(etype: string | null = null) {
+    await this.queryRun('SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";');
+    if (etype != null) {
+      await this.createEntitiesTable(etype);
+      await this.createDataTable(etype);
+      await this.createReferencesTable(etype);
+      await this.createTokensTable(etype);
+      await this.createUniquesTable(etype);
     } else {
       // Create the UID table.
-      this.queryRunSync(
+      await this.queryRun(
         `CREATE TABLE IF NOT EXISTS ${MySQLDriver.escape(
-          `${this.prefix}uids`
+          `${this.prefix}uids`,
         )} (
           \`name\` TEXT NOT NULL,
           \`cur_uid\` BIGINT(20) UNSIGNED NOT NULL,
           PRIMARY KEY (\`name\`(100))
         ) ENGINE ${this.config.engine}
-        CHARACTER SET utf8 COLLATE utf8_bin;`
+        CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;`,
       );
     }
+    if (
+      this.transaction &&
+      this.transaction.count > 0 &&
+      this.config.transactions
+    ) {
+      this.transaction.count = 0;
+      this.transaction.connection?.release();
+      this.transaction.connection = null;
+      this.transaction = null;
+    }
     return true;
   }
 
   private translateQuery(
     origQuery: string,
-    origParams: { [k: string]: any }
+    origParams: { [k: string]: any },
   ): { query: string; params: any[] } {
     const params: any[] = [];
     let query = origQuery;
@@ -296,32 +470,37 @@ export default class MySQLDriver 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('mysql:query', query);
       return await runQuery();
     } catch (e: any) {
       const errorCode = e?.errno;
-      if (errorCode === 1146 && this.createTables()) {
+      if (errorCode === 1146 && (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?.errno + ' - ' + e2?.message,
-            query
+            query,
+            e2?.errno,
           );
         }
+      } else if (errorCode === 1062) {
+        throw new EntityUniqueConstraintError(`Unique constraint violation.`);
       } else if (errorCode === 2006) {
         // If the MySQL server disconnected, reconnect to it.
-        if (!this.connect()) {
+        if (!(await this.connect())) {
           throw new QueryFailedError(
             'Query failed: ' + e?.errno + ' - ' + e?.message,
-            query
+            query,
+            e?.errno,
           );
         }
         try {
@@ -329,60 +508,21 @@ export default class MySQLDriver extends NymphDriver {
         } catch (e2: any) {
           throw new QueryFailedError(
             'Query failed: ' + e2?.errno + ' - ' + 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?.errno;
-      if (errorCode === 1146 && 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?.errno + ' - ' + e2?.message,
-            query
-          );
-        }
-      } else if (errorCode === 2006) {
-        // If the MySQL server disconnected, reconnect to it.
-        if (!this.connect()) {
-          throw new QueryFailedError(
-            'Query failed: ' + e?.errno + ' - ' + e?.message,
-            query
-          );
-        }
-        try {
-          return runQuery();
-        } catch (e2: any) {
-          throw new QueryFailedError(
-            'Query failed: ' + e2?.errno + ' - ' + e2?.message,
-            query
+            query,
+            e2?.errno,
           );
         }
       } else {
-        throw e;
+        throw new QueryFailedError(
+          'Query failed: ' + e?.errno + ' - ' + e?.message,
+          query,
+          e?.errno,
+        );
       }
     }
   }
 
-  private queryIter(
+  private queryArray(
     query: string,
     {
       etypes = [],
@@ -390,82 +530,42 @@ export default class MySQLDriver extends NymphDriver {
     }: {
       etypes?: string[];
       params?: { [k: string]: any };
-    } = {}
+    } = {},
   ) {
     const { query: newQuery, params: newParams } = this.translateQuery(
       query,
-      params
+      params,
     );
     return this.query(
       async () => {
-        const results: any = await new Promise((resolve, reject) => {
-          try {
-            (this.transaction?.connection ?? this.link).query(
-              newQuery,
-              newParams,
-              (error, results) => {
-                if (error) {
-                  reject(error);
-                }
+        const results: any = await new Promise(async (resolve, reject) => {
+          // Only do one query at a time in transations.
+          let myResolve: (value: void | PromiseLike<void>) => void = () => {};
+          const myPromise = new Promise<void>((resolve) => {
+            myResolve = resolve;
+          });
+          if (this.transaction) {
+            const latestPromise = this.transaction.latestPromise;
+            this.transaction.latestPromise = myPromise;
+            await latestPromise;
+          }
+          (this.transaction?.connection ?? this.link).query(
+            newQuery,
+            newParams,
+            (error, results) => {
+              if (error) {
+                reject(error);
+              } else {
                 resolve(results);
               }
-            );
-          } catch (e) {
-            reject(e);
-          }
+              myResolve();
+            },
+          );
         });
         return results;
       },
       `${query} -- ${JSON.stringify(params)}`,
-      etypes
-    );
-  }
-
-  private queryIterSync(
-    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 + '/runMysqlSync.js'],
-          {
-            input: JSON.stringify({
-              mysqlConfig: this.mysqlConfig,
-              query: newQuery,
-              params: newParams,
-            }),
-            timeout: 30000,
-            maxBuffer: 100 * 1024 * 1024,
-            encoding: 'utf8',
-            windowsHide: true,
-          }
-        );
-        try {
-          const { results } = JSON.parse(output.stdout);
-          return results;
-        } 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,
     );
   }
 
@@ -477,34 +577,42 @@ export default class MySQLDriver extends NymphDriver {
     }: {
       etypes?: string[];
       params?: { [k: string]: any };
-    } = {}
+    } = {},
   ) {
     const { query: newQuery, params: newParams } = this.translateQuery(
       query,
-      params
+      params,
     );
     return this.query(
       async () => {
-        const results: any = await new Promise((resolve, reject) => {
-          try {
-            (this.transaction?.connection ?? this.link).query(
-              newQuery,
-              newParams,
-              (error, results) => {
-                if (error) {
-                  reject(error);
-                }
+        const results: any = await new Promise(async (resolve, reject) => {
+          // Only do one query at a time in transations.
+          let myResolve: (value: void | PromiseLike<void>) => void = () => {};
+          const myPromise = new Promise<void>((resolve) => {
+            myResolve = resolve;
+          });
+          if (this.transaction) {
+            const latestPromise = this.transaction.latestPromise;
+            this.transaction.latestPromise = myPromise;
+            await latestPromise;
+          }
+          (this.transaction?.connection ?? this.link).query(
+            newQuery,
+            newParams,
+            (error, results) => {
+              if (error) {
+                reject(error);
+              } else {
                 resolve(results);
               }
-            );
-          } catch (e) {
-            reject(e);
-          }
+              myResolve();
+            },
+          );
         });
         return results[0];
       },
       `${query} -- ${JSON.stringify(params)}`,
-      etypes
+      etypes,
     );
   }
 
@@ -513,92 +621,55 @@ export default class MySQLDriver extends NymphDriver {
     {
       etypes = [],
       params = {},
+      transaction,
     }: {
       etypes?: string[];
       params?: { [k: string]: any };
-    } = {}
+      transaction?: MySQLDriverTransaction;
+    } = {},
   ) {
     const { query: newQuery, params: newParams } = this.translateQuery(
       query,
-      params
+      params,
     );
     return this.query(
       async () => {
-        const results: any = await new Promise((resolve, reject) => {
-          try {
-            (this.transaction?.connection ?? this.link).query(
-              newQuery,
-              newParams,
-              (error, results) => {
-                if (error) {
-                  reject(error);
-                }
+        const results: any = await new Promise(async (resolve, reject) => {
+          // Only do one query at a time in transations.
+          let myResolve: (value: void | PromiseLike<void>) => void = () => {};
+          const myPromise = new Promise<void>((resolve) => {
+            myResolve = resolve;
+          });
+          const trans = transaction ?? this.transaction;
+          if (trans) {
+            const latestPromise = trans.latestPromise;
+            trans.latestPromise = myPromise;
+            await latestPromise;
+          }
+          (trans?.connection ?? this.link).query(
+            newQuery,
+            newParams,
+            (error, results) => {
+              if (error) {
+                reject(error);
+              } else {
                 resolve(results);
               }
-            );
-          } catch (e) {
-            reject(e);
-          }
+              myResolve();
+            },
+          );
         });
         return { changes: results.changedRows ?? 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 + '/runMysqlSync.js'],
-          {
-            input: JSON.stringify({
-              mysqlConfig: this.mysqlConfig,
-              query: newQuery,
-              params: newParams,
-            }),
-            timeout: 30000,
-            maxBuffer: 100 * 1024 * 1024,
-            encoding: 'utf8',
-            windowsHide: true,
-          }
-        );
-        try {
-          const { results } = JSON.parse(output.stdout);
-          return { changes: results.changedRows ?? 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) {
@@ -620,7 +691,7 @@ export default class MySQLDriver extends NymphDriver {
 
   public async deleteEntityByID(
     guid: string,
-    className?: EntityConstructor | string | null
+    className?: EntityConstructor | string | null,
   ) {
     let EntityClass: EntityConstructor;
     if (typeof className === 'string' || className == null) {
@@ -634,58 +705,71 @@ export default class MySQLDriver extends NymphDriver {
     try {
       await this.queryRun(
         `DELETE FROM ${MySQLDriver.escape(
-          `${this.prefix}entities_${etype}`
+          `${this.prefix}entities_${etype}`,
         )} WHERE \`guid\`=UNHEX(@guid);`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
       );
       await this.queryRun(
         `DELETE FROM ${MySQLDriver.escape(
-          `${this.prefix}data_${etype}`
+          `${this.prefix}data_${etype}`,
         )} WHERE \`guid\`=UNHEX(@guid);`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
       );
       await this.queryRun(
         `DELETE FROM ${MySQLDriver.escape(
-          `${this.prefix}comparisons_${etype}`
+          `${this.prefix}references_${etype}`,
         )} WHERE \`guid\`=UNHEX(@guid);`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
       );
       await this.queryRun(
         `DELETE FROM ${MySQLDriver.escape(
-          `${this.prefix}references_${etype}`
+          `${this.prefix}tokens_${etype}`,
         )} WHERE \`guid\`=UNHEX(@guid);`,
         {
           etypes: [etype],
           params: {
             guid,
           },
-        }
+        },
+      );
+      await this.queryRun(
+        `DELETE FROM ${MySQLDriver.escape(
+          `${this.prefix}uniques_${etype}`,
+        )} WHERE \`guid\`=UNHEX(@guid);`,
+        {
+          etypes: [etype],
+          params: {
+            guid,
+          },
+        },
       );
-      await this.commit('nymph-delete');
-      // Remove any cached versions of this entity.
-      if (this.nymph.config.cache) {
-        this.cleanCache(guid);
-      }
-      return true;
     } catch (e: any) {
+      this.nymph.config.debugError('mysql', `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) {
@@ -694,101 +778,363 @@ export default class MySQLDriver extends NymphDriver {
     }
     await this.queryRun(
       `DELETE FROM ${MySQLDriver.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 getIndexes(etype: string) {
+    const indexes: {
+      scope: 'data' | 'references' | 'tokens';
+      name: string;
+      property: string;
+    }[] = [];
 
-    writeLine('#');
-    writeLine('# UIDs');
-    writeLine('#');
-    writeLine('');
+    for (let [scope, suffix] of [
+      ['data', '_string_guid'],
+      ['references', '_reference_guid'],
+      ['tokens', '_token_guid'],
+    ] as (
+      | ['data', '_string_guid']
+      | ['references', '_reference_guid']
+      | ['tokens', '_token_guid']
+    )[]) {
+      const indexDefinitions = await this.queryArray(
+        `SHOW INDEXES FROM ${MySQLDriver.escape(
+          `${this.prefix}${scope}_${etype}`,
+        )} WHERE \`Key_name\` LIKE @pattern AND \`Seq_in_index\`=1;`,
+        {
+          params: {
+            pattern: `${this.prefix}${scope}_${etype}_id_custom_%${suffix}`,
+          },
+        },
+      );
+      for (const indexDefinition of indexDefinitions) {
+        indexes.push({
+          scope,
+          name: (indexDefinition.Key_name as string).substring(
+            `${this.prefix}${scope}_${etype}_id_custom_`.length,
+            indexDefinition.Key_name.length - suffix.length,
+          ),
+          property:
+            ((indexDefinition.Expression as string).match(
+              /\s*\(?\s*`?name`?\s*=\s*(?:\w*)\\*'(.*?)\\*'/,
+            ) ?? [])[1] ?? '',
+        });
+      }
+    }
 
-    // Export UIDs.
-    let uids = await this.queryIter(
+    return indexes;
+  }
+
+  public async addIndex(
+    etype: string,
+    definition: {
+      scope: 'data' | 'references' | 'tokens';
+      name: string;
+      property: string;
+    },
+  ) {
+    this.checkIndexName(definition.name);
+    await this.deleteIndex(etype, definition.scope, definition.name);
+    if (definition.scope === 'data') {
+      await this.queryRun(
+        `CREATE INDEX ${MySQLDriver.escape(
+          `${this.prefix}data_${etype}_id_custom_${definition.name}_string_guid`,
+        )} USING btree ON ${MySQLDriver.escape(
+          `${this.prefix}data_${etype}`,
+        )} (((\`name\` = ${MySQLDriver.escapeValue(definition.property)})), \`string\`(500), \`guid\`);`,
+      );
+      await this.queryRun(
+        `CREATE INDEX ${MySQLDriver.escape(
+          `${this.prefix}data_${etype}_id_custom_${definition.name}_number_guid`,
+        )} USING btree ON ${MySQLDriver.escape(
+          `${this.prefix}data_${etype}`,
+        )} (((\`name\` = ${MySQLDriver.escapeValue(definition.property)})), \`number\`, \`guid\`);`,
+      );
+      await this.queryRun(
+        `CREATE INDEX ${MySQLDriver.escape(
+          `${this.prefix}data_${etype}_id_custom_${definition.name}_truthy_guid`,
+        )} USING btree ON ${MySQLDriver.escape(
+          `${this.prefix}data_${etype}`,
+        )} (((\`name\` = ${MySQLDriver.escapeValue(definition.property)})), \`truthy\`, \`guid\`);`,
+      );
+      await this.queryRun(
+        `CREATE INDEX ${MySQLDriver.escape(
+          `${this.prefix}data_${etype}_id_custom_${definition.name}_json_guid`,
+        )} USING btree ON ${MySQLDriver.escape(
+          `${this.prefix}data_${etype}`,
+        )} (((\`name\` = ${MySQLDriver.escapeValue(definition.property)})), (CAST(\`json\` AS CHAR(500)) COLLATE utf8mb4_bin), \`guid\`);`,
+      );
+    } else if (definition.scope === 'references') {
+      await this.queryRun(
+        `CREATE INDEX ${MySQLDriver.escape(
+          `${this.prefix}references_${etype}_id_custom_${definition.name}_reference_guid`,
+        )} USING btree ON ${MySQLDriver.escape(
+          `${this.prefix}references_${etype}`,
+        )} (((\`name\` = ${MySQLDriver.escapeValue(definition.property)})), \`reference\`, \`guid\`);`,
+      );
+    } else if (definition.scope === 'tokens') {
+      await this.queryRun(
+        `CREATE INDEX ${MySQLDriver.escape(
+          `${this.prefix}tokens_${etype}_id_custom_${definition.name}_token_guid`,
+        )} USING btree ON ${MySQLDriver.escape(
+          `${this.prefix}tokens_${etype}`,
+        )} (((\`name\` = ${MySQLDriver.escapeValue(definition.property)})), \`token\`, \`guid\`);`,
+      );
+    }
+    return true;
+  }
+
+  public async deleteIndex(
+    etype: string,
+    scope: 'data' | 'references' | 'tokens',
+    name: string,
+  ) {
+    this.checkIndexName(name);
+    try {
+      if (scope === 'data') {
+        await this.queryRun(
+          `DROP INDEX ${MySQLDriver.escape(
+            `${this.prefix}data_${etype}_id_custom_${name}_string_guid`,
+          )} ON ${MySQLDriver.escape(`${this.prefix}data_${etype}`)};`,
+        );
+        await this.queryRun(
+          `DROP INDEX ${MySQLDriver.escape(
+            `${this.prefix}data_${etype}_id_custom_${name}_number_guid`,
+          )} ON ${MySQLDriver.escape(`${this.prefix}data_${etype}`)};`,
+        );
+        await this.queryRun(
+          `DROP INDEX ${MySQLDriver.escape(
+            `${this.prefix}data_${etype}_id_custom_${name}_truthy_guid`,
+          )} ON ${MySQLDriver.escape(`${this.prefix}data_${etype}`)};`,
+        );
+        await this.queryRun(
+          `DROP INDEX ${MySQLDriver.escape(
+            `${this.prefix}data_${etype}_id_custom_${name}_json_guid`,
+          )} ON ${MySQLDriver.escape(`${this.prefix}data_${etype}`)};`,
+        );
+      } else if (scope === 'references') {
+        await this.queryRun(
+          `DROP INDEX ${MySQLDriver.escape(
+            `${this.prefix}references_${etype}_id_custom_${name}_reference_guid`,
+          )} ON ${MySQLDriver.escape(`${this.prefix}references_${etype}`)};`,
+        );
+      } else if (scope === 'tokens') {
+        await this.queryRun(
+          `DROP INDEX ${MySQLDriver.escape(
+            `${this.prefix}tokens_${etype}_id_custom_${name}_token_guid`,
+          )} ON ${MySQLDriver.escape(`${this.prefix}tokens_${etype}`)};`,
+        );
+      }
+    } catch (e: any) {
+      if (e?.errorCode !== 1091) {
+        throw e;
+      }
+    }
+    return true;
+  }
+
+  public async getEtypes() {
+    const tables = await this.queryArray(
+      'SELECT `table_name` AS `table_name` FROM `information_schema`.`tables` WHERE `table_schema`=@db AND `table_name` LIKE @prefix;',
+      {
+        params: {
+          db: this.config.database,
+          prefix: this.prefix + 'entities_' + '%',
+        },
+      },
+    );
+    const etypes: string[] = [];
+    for (const table of tables) {
+      etypes.push(table.table_name.substr((this.prefix + 'entities_').length));
+    }
+
+    return etypes;
+  }
+
+  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: `
+
+#
+# UIDs
+#
+
+`,
+      }
+    ) {
+      return;
+    }
+
+    // Export UIDs.
+    let uids = await this.queryArray(
       `SELECT * FROM ${MySQLDriver.escape(
-        `${this.prefix}uids`
-      )} ORDER BY \`name\`;`
+        `${this.prefix}uids`,
+      )} ORDER BY \`name\`;`,
     );
     for (const uid of uids) {
-      writeLine(`<${uid.name}>[${uid.cur_uid}]`);
+      if (yield { type: 'uid', content: `<${uid.name}>[${uid.cur_uid}]\n` }) {
+        return;
+      }
     }
 
-    writeLine('');
-    writeLine('#');
-    writeLine('# Entities');
-    writeLine('#');
-    writeLine('');
+    if (
+      yield {
+        type: 'comment',
+        content: `
 
-    // Get the etypes.
-    const tables = await this.queryIter('SHOW TABLES;');
-    const etypes = [];
-    for (const tableRow of tables) {
-      const table = tableRow[Object.keys(tableRow)[0]];
-      if (table.startsWith(this.prefix + 'entities_')) {
-        etypes.push(table.substr((this.prefix + 'entities_').length));
+#
+# Entities
+#
+
+`,
       }
+    ) {
+      return;
     }
 
+    // Get the etypes.
+    const etypes = await this.getEtypes();
+
     for (const etype of etypes) {
       // Export entities.
-      const dataIterator = (
-        await this.queryIter(
-          `SELECT LOWER(HEX(e.\`guid\`)) AS \`guid\`, e.\`tags\`, e.\`cdate\`, e.\`mdate\`, d.\`name\` AS \`dname\`, d.\`value\` AS \`dvalue\`, c.\`string\`, c.\`number\`
+      const entityIterator = this.exportEntityInternal(etype);
+      for await (let content of entityIterator) {
+        yield { type: 'entity', content };
+      }
+    }
+  }
+
+  public async exportEntity(etype: string, guid: string): Promise<string> {
+    const entityIterator = this.exportEntityInternal(etype, guid);
+    let exportContent = '';
+    for await (let content of entityIterator) {
+      exportContent += content;
+    }
+
+    return exportContent;
+  }
+
+  private async *exportEntityInternal(
+    etype: string,
+    guid?: string,
+  ): AsyncGenerator<string, void, false | undefined> {
+    // Export entities.
+    const dataIterator = (
+      await this.queryArray(
+        `SELECT LOWER(HEX(e.\`guid\`)) AS \`guid\`, e.\`tags\`, e.\`cdate\`, e.\`mdate\`, LOWER(HEX(e.\`user\`)) AS \`user\`, LOWER(HEX(e.\`group\`)) AS \`group\`, e.\`acUser\`, e.\`acGroup\`, e.\`acOther\`, e.\`acRead\`, e.\`acWrite\`, e.\`acFull\`, d.\`name\`, d.\`value\`, d.\`json\`, d.\`string\`, d.\`number\`
           FROM ${MySQLDriver.escape(`${this.prefix}entities_${etype}`)} e
           LEFT JOIN ${MySQLDriver.escape(
-            `${this.prefix}data_${etype}`
-          )} d ON e.\`guid\`=d.\`guid\`
-          INNER JOIN ${MySQLDriver.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();
-      while (!datum.done) {
-        const guid = datum.value.guid;
-        const tags = datum.value.tags.slice(1, -1).split(' ').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) {
-          // 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'
-                ? JSON.stringify(datum.value.number)
-                : datum.value.dvalue === 'S'
+            `${this.prefix}data_${etype}`,
+          )} d ON e.\`guid\`=d.\`guid\`${guid == null ? '' : ` WHERE e.\`guid\`=UNHEX(@guid)`}
+          ORDER BY e.\`guid\`, d.\`name\`;`,
+        guid == null ? undefined : { params: { guid } },
+      )
+    )[Symbol.iterator]();
+    let datum = dataIterator.next();
+    while (!datum.done) {
+      const guid = datum.value.guid;
+      const tags = datum.value.tags
+        .slice(1, -1)
+        .split(' ')
+        .filter((tag: string) => tag)
+        .join(',');
+      const cdate = datum.value.cdate;
+      const mdate = datum.value.mdate;
+      const user = datum.value.user;
+      const group = datum.value.group;
+      const acUser = datum.value.acUser;
+      const acGroup = datum.value.acGroup;
+      const acOther = datum.value.acOther;
+      const acRead = datum.value.acRead?.slice(1, -1).split(' ');
+      const acWrite = datum.value.acWrite?.slice(1, -1).split(' ');
+      const acFull = datum.value.acFull?.slice(1, -1).split(' ');
+      let currentEntityExport: string[] = [];
+      currentEntityExport.push(`{${guid}}<${etype}>[${tags}]`);
+      currentEntityExport.push(`\tcdate=${JSON.stringify(cdate)}`);
+      currentEntityExport.push(`\tmdate=${JSON.stringify(mdate)}`);
+      if (this.nymph.tilmeld != null) {
+        if (user != null) {
+          currentEntityExport.push(
+            `\tuser=${JSON.stringify(['nymph_entity_reference', user, 'User'])}`,
+          );
+        }
+        if (group != null) {
+          currentEntityExport.push(
+            `\tgroup=${JSON.stringify(['nymph_entity_reference', group, 'Group'])}`,
+          );
+        }
+        if (acUser != null) {
+          currentEntityExport.push(`\tacUser=${JSON.stringify(acUser)}`);
+        }
+        if (acGroup != null) {
+          currentEntityExport.push(`\tacGroup=${JSON.stringify(acGroup)}`);
+        }
+        if (acOther != null) {
+          currentEntityExport.push(`\tacOther=${JSON.stringify(acOther)}`);
+        }
+        if (acRead != null) {
+          currentEntityExport.push(`\tacRead=${JSON.stringify(acRead)}`);
+        }
+        if (acWrite != null) {
+          currentEntityExport.push(`\tacWrite=${JSON.stringify(acWrite)}`);
+        }
+        if (acFull != null) {
+          currentEntityExport.push(`\tacFull=${JSON.stringify(acFull)}`);
+        }
+      }
+      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.value === 'N'
+              ? JSON.stringify(datum.value.number)
+              : datum.value.value === 'S'
                 ? JSON.stringify(datum.value.string)
-                : datum.value.dvalue;
-            writeLine(`\t${datum.value.dname}=${value}`);
-            datum = dataIterator.next();
-          } while (!datum.done && datum.value.guid === guid);
-        } else {
-          // Make sure that datum is incremented :)
+                : datum.value.value === 'J'
+                  ? JSON.stringify(datum.value.json)
+                  : datum.value.value;
+          currentEntityExport.push(`\t${datum.value.name}=${value}`);
           datum = dataIterator.next();
-        }
+        } while (!datum.done && datum.value.guid === guid);
+      } else {
+        // Make sure that datum is incremented :)
+        datum = dataIterator.next();
       }
-    }
+      currentEntityExport.push('');
 
-    return;
+      if (yield currentEntityExport.join('\n')) {
+        return;
+      }
+    }
   }
 
   /**
@@ -809,21 +1155,23 @@ export default class MySQLDriver extends NymphDriver {
     params: { [k: string]: any } = {},
     subquery = false,
     tableSuffix = '',
-    etypes: string[] = []
+    etypes: string[] = [],
+    guidSelector: string | undefined = undefined,
+    guidExplicitSelector: ((guid: string) => 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 sort = options.sort ?? 'cdate';
+    const sTable = `s${tableSuffix}`;
+    const sort = options.sort === undefined ? 'cdate' : options.sort;
     const queryParts = this.iterateSelectorsForQuery(
       formattedSelectors,
-      (key, value, typeIsOr, typeIsNot) => {
+      ({ key, value, typeIsOr, typeIsNot }) => {
         const clauseNot = key.startsWith('!');
         let curQuery = '';
         for (const curValue of value) {
@@ -885,17 +1233,39 @@ export default class MySQLDriver extends NymphDriver {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const name = `param${++count.i}`;
-                curQuery +=
-                  ieTable +
-                  '.`guid` ' +
-                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  'IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
-                  ' WHERE `name`=@' +
-                  name +
-                  ')';
-                params[name] = curVar;
+                if (
+                  curVar === 'cdate' ||
+                  curVar === 'mdate' ||
+                  (this.nymph.tilmeld != null &&
+                    (curVar === 'user' ||
+                      curVar === 'group' ||
+                      curVar === 'acUser' ||
+                      curVar === 'acGroup' ||
+                      curVar === 'acOther' ||
+                      curVar === 'acRead' ||
+                      curVar === 'acWrite' ||
+                      curVar === 'acFull'))
+                ) {
+                  curQuery +=
+                    (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                    '(' +
+                    ieTable +
+                    '.' +
+                    MySQLDriver.escape(curVar) +
+                    ' IS NOT NULL)';
+                } else {
+                  const name = `param${++count.i}`;
+                  curQuery +=
+                    (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                    'EXISTS (SELECT `guid` FROM ' +
+                    MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                    ' WHERE `guid`=' +
+                    ieTable +
+                    '.`guid` AND `name`=@' +
+                    name +
+                    ')';
+                  params[name] = curVar;
+                }
               }
               break;
             case 'truthy':
@@ -904,28 +1274,35 @@ export default class MySQLDriver extends NymphDriver {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                if (curVar === 'cdate') {
-                  curQuery +=
-                    (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                    '(' +
-                    ieTable +
-                    '.`cdate` NOT NULL)';
-                  break;
-                } else if (curVar === 'mdate') {
+                if (
+                  curVar === 'cdate' ||
+                  curVar === 'mdate' ||
+                  (this.nymph.tilmeld != null &&
+                    (curVar === 'user' ||
+                      curVar === 'group' ||
+                      curVar === 'acUser' ||
+                      curVar === 'acGroup' ||
+                      curVar === 'acOther' ||
+                      curVar === 'acRead' ||
+                      curVar === 'acWrite' ||
+                      curVar === 'acFull'))
+                ) {
                   curQuery +=
                     (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                     '(' +
                     ieTable +
-                    '.`mdate` NOT NULL)';
-                  break;
+                    '.' +
+                    MySQLDriver.escape(curVar) +
+                    ' IS NOT NULL)';
                 } else {
                   const name = `param${++count.i}`;
                   curQuery +=
                     (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                    'EXISTS (SELECT `guid` FROM ' +
+                    MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                    ' WHERE `guid`=' +
                     ieTable +
-                    '.`guid` IN (SELECT `guid` FROM ' +
-                    MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                    ' WHERE `name`=@' +
+                    '.`guid` AND `name`=@' +
                     name +
                     ' AND `truthy`=TRUE)';
                   params[name] = curVar;
@@ -934,34 +1311,65 @@ export default class MySQLDriver extends NymphDriver {
               break;
             case 'equal':
             case '!equal':
-              if (curValue[0] === 'cdate') {
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther'))
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const cdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   ieTable +
-                  '.`cdate`=@' +
-                  cdate;
-                params[cdate] = isNaN(Number(curValue[1]))
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  '=@' +
+                  value;
+                params[value] = isNaN(Number(curValue[1]))
                   ? null
                   : Number(curValue[1]);
-                break;
-              } else if (curValue[0] === 'mdate') {
+              } else if (
+                this.nymph.tilmeld != null &&
+                (curValue[0] === 'user' || curValue[0] === 'group')
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const mdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   ieTable +
-                  '.`mdate`=@' +
-                  mdate;
-                params[mdate] = isNaN(Number(curValue[1]))
-                  ? null
-                  : Number(curValue[1]);
-                break;
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  '=UNHEX(@' +
+                  value +
+                  ')';
+                params[value] = `${curValue[1]}`;
+              } else if (
+                this.nymph.tilmeld != null &&
+                (curValue[0] === 'acRead' ||
+                  curValue[0] === 'acWrite' ||
+                  curValue[0] === 'acFull')
+              ) {
+                if (curQuery) {
+                  curQuery += typeIsOr ? ' OR ' : ' AND ';
+                }
+                const value = `param${++count.i}`;
+                curQuery +=
+                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  ieTable +
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  '=@' +
+                  value;
+                params[value] = Array.isArray(curValue[1])
+                  ? ' ' + curValue[1].join(' ') + ' '
+                  : '';
               } else if (typeof curValue[1] === 'number') {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -970,10 +1378,11 @@ export default class MySQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
                   ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                  ' WHERE `name`=@' +
+                  '.`guid` AND `name`=@' +
                   name +
                   ' AND `number`=@' +
                   value +
@@ -988,10 +1397,11 @@ export default class MySQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
                   ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                  ' WHERE `name`=@' +
+                  '.`guid` AND `name`=@' +
                   name +
                   ' AND `string`=@' +
                   value +
@@ -1013,136 +1423,313 @@ export default class MySQLDriver extends NymphDriver {
                 }
                 const name = `param${++count.i}`;
                 const value = `param${++count.i}`;
-                curQuery +=
-                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
-                  ' WHERE `name`=@' +
-                  name +
-                  ' AND `value`=@' +
-                  value +
-                  ')';
+                if (svalue.length < 500) {
+                  curQuery +=
+                    (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                    'EXISTS (SELECT `guid` FROM ' +
+                    MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                    ' WHERE `guid`=' +
+                    ieTable +
+                    '.`guid` AND `name`=@' +
+                    name +
+                    ' AND (CAST(`json` AS CHAR(500)) COLLATE utf8mb4_bin)=CAST(CAST(@' +
+                    value +
+                    ' AS JSON) AS CHAR(500)))';
+                } else {
+                  curQuery +=
+                    (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                    'EXISTS (SELECT `guid` FROM ' +
+                    MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                    ' WHERE `guid`=' +
+                    ieTable +
+                    '.`guid` AND `name`=@' +
+                    name +
+                    ' AND `json`=CAST(@' +
+                    value +
+                    ' AS JSON))';
+                }
                 params[name] = curValue[0];
                 params[value] = svalue;
               }
               break;
             case 'contain':
             case '!contain':
-              if (curValue[0] === 'cdate') {
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther'))
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const cdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   ieTable +
-                  '.`cdate`=' +
-                  cdate;
-                params[cdate] = isNaN(Number(curValue[1]))
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  '=@' +
+                  value;
+                params[value] = isNaN(Number(curValue[1]))
                   ? null
                   : Number(curValue[1]);
-                break;
-              } else if (curValue[0] === 'mdate') {
+              } else if (
+                this.nymph.tilmeld != null &&
+                (curValue[0] === 'user' || curValue[0] === 'group')
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const mdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   ieTable +
-                  '.`mdate`=' +
-                  mdate;
-                params[mdate] = isNaN(Number(curValue[1]))
-                  ? null
-                  : Number(curValue[1]);
-                break;
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  '=UNHEX(@' +
+                  value +
+                  ')';
+                params[value] = `${curValue[1]}`;
+              } else if (
+                this.nymph.tilmeld != null &&
+                (curValue[0] === 'acRead' ||
+                  curValue[0] === 'acWrite' ||
+                  curValue[0] === 'acFull')
+              ) {
+                if (curQuery) {
+                  curQuery += typeIsOr ? ' OR ' : ' AND ';
+                }
+                const queryParam = `param${++count.i}`;
+                curQuery +=
+                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'MATCH (' +
+                  ieTable +
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  ') AGAINST (@' +
+                  queryParam +
+                  ' IN BOOLEAN MODE)';
+                params[queryParam] = '+' + curValue[1];
               } else {
                 if (curQuery) {
                   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 {
                   svalue = JSON.stringify(curValue[1]);
-                  stringValue = `${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 ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
+                  ieTable +
+                  '.`guid` AND `name`=@' +
+                  name +
+                  ' AND JSON_CONTAINS(`json`, @' +
+                  value +
+                  '))';
+                params[name] = curValue[0];
+                params[value] = svalue;
+              }
+              break;
+            case 'search':
+            case '!search':
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'user' ||
+                    curValue[0] === 'group' ||
+                    curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther' ||
+                    curValue[0] === 'acRead' ||
+                    curValue[0] === 'acWrite' ||
+                    curValue[0] === 'acFull'))
+              ) {
+                if (curQuery) {
+                  curQuery += typeIsOr ? ' OR ' : ' AND ';
+                }
+                curQuery +=
+                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') + '(FALSE)';
+              } else {
+                if (curQuery) {
+                  curQuery += typeIsOr ? ' OR ' : ' AND ';
+                }
+
+                const parsedFTSQuery = this.tokenizer.parseSearchQuery(
+                  curValue[1],
+                );
+
+                if (!parsedFTSQuery.length) {
                   curQuery +=
-                    (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                    '(' +
-                    ieTable +
-                    '.`guid` IN (SELECT `guid` FROM ' +
-                    MySQLDriver.escape(this.prefix + 'data_' + etype) +
-                    ' WHERE `name`=@' +
-                    name +
-                    ' AND INSTR(`value`, @' +
-                    value +
-                    ')) OR ' +
-                    ieTable +
-                    '.`guid` IN (SELECT `guid` FROM ' +
-                    MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                    ' WHERE `name`=@' +
-                    name +
-                    ' AND `string`=@' +
-                    stringParam +
-                    '))';
-                  params[stringParam] = stringValue;
+                    (xor(typeIsNot, clauseNot) ? 'NOT ' : '') + '(FALSE)';
                 } else {
+                  const name = `param${++count.i}`;
+
+                  const queryPartToken = (term: SearchTerm) => {
+                    const value = `param${++count.i}`;
+                    params[value] = term.token;
+                    return (
+                      'EXISTS (SELECT `guid` FROM ' +
+                      MySQLDriver.escape(this.prefix + 'tokens_' + etype) +
+                      ' WHERE `guid`=' +
+                      ieTable +
+                      '.`guid` AND `name`=@' +
+                      name +
+                      ' AND `token`=@' +
+                      value +
+                      (term.nostemmed ? ' AND `stem`=FALSE' : '') +
+                      ')'
+                    );
+                  };
+
+                  const queryPartSeries = (series: SearchSeriesTerm) => {
+                    const tokenTableSuffix = makeTableSuffix();
+                    const tokenParts = series.tokens.map((token, i) => {
+                      const value = `param${++count.i}`;
+                      params[value] = token.token;
+                      return {
+                        fromClause:
+                          i === 0
+                            ? 'FROM ' +
+                              MySQLDriver.escape(
+                                this.prefix + 'tokens_' + etype,
+                              ) +
+                              ' t' +
+                              tokenTableSuffix +
+                              '0'
+                            : 'JOIN ' +
+                              MySQLDriver.escape(
+                                this.prefix + 'tokens_' + etype,
+                              ) +
+                              ' t' +
+                              tokenTableSuffix +
+                              i +
+                              ' ON t' +
+                              tokenTableSuffix +
+                              i +
+                              '.`guid` = t' +
+                              tokenTableSuffix +
+                              '0.`guid` AND t' +
+                              tokenTableSuffix +
+                              i +
+                              '.`name` = t' +
+                              tokenTableSuffix +
+                              '0.`name` AND t' +
+                              tokenTableSuffix +
+                              i +
+                              '.`position` = t' +
+                              tokenTableSuffix +
+                              '0.`position` + ' +
+                              i,
+                        whereClause:
+                          't' +
+                          tokenTableSuffix +
+                          i +
+                          '.`token`=@' +
+                          value +
+                          (token.nostemmed
+                            ? ' AND t' + tokenTableSuffix + i + '.`stem`=FALSE'
+                            : ''),
+                      };
+                    });
+                    return (
+                      'EXISTS (SELECT t' +
+                      tokenTableSuffix +
+                      '0.`guid` ' +
+                      tokenParts.map((part) => part.fromClause).join(' ') +
+                      ' WHERE t' +
+                      tokenTableSuffix +
+                      '0.`guid`=' +
+                      ieTable +
+                      '.`guid` AND t' +
+                      tokenTableSuffix +
+                      '0.`name`=@' +
+                      name +
+                      ' AND ' +
+                      tokenParts.map((part) => part.whereClause).join(' AND ') +
+                      ')'
+                    );
+                  };
+
+                  const queryPartTerm = (
+                    term:
+                      | SearchTerm
+                      | SearchOrTerm
+                      | SearchNotTerm
+                      | SearchSeriesTerm,
+                  ): string => {
+                    if (term.type === 'series') {
+                      return queryPartSeries(term);
+                    } else if (term.type === 'not') {
+                      return 'NOT ' + queryPartTerm(term.operand);
+                    } else if (term.type === 'or') {
+                      let queryParts: string[] = [];
+                      for (let operand of term.operands) {
+                        queryParts.push(queryPartTerm(operand));
+                      }
+                      return '(' + queryParts.join(' OR ') + ')';
+                    }
+                    return queryPartToken(term);
+                  };
+
+                  // Run through the query and add terms.
+                  let termStrings: string[] = [];
+                  for (let term of parsedFTSQuery) {
+                    termStrings.push(queryPartTerm(term));
+                  }
+
                   curQuery +=
                     (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                    ieTable +
-                    '.`guid` IN (SELECT `guid` FROM ' +
-                    MySQLDriver.escape(this.prefix + 'data_' + etype) +
-                    ' WHERE `name`=@' +
-                    name +
-                    ' AND INSTR(`value`, @' +
-                    value +
-                    '))';
+                    '(' +
+                    termStrings.join(' AND ') +
+                    ')';
+
+                  params[name] = curValue[0];
                 }
-                params[name] = curValue[0];
-                params[value] = svalue;
               }
               break;
             case 'match':
             case '!match':
-              if (curValue[0] === 'cdate') {
-                if (curQuery) {
-                  curQuery += typeIsOr ? ' OR ' : ' AND ';
-                }
-                const cdate = `param${++count.i}`;
-                curQuery +=
-                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  '(' +
-                  ieTable +
-                  '.`cdate` REGEXP @' +
-                  cdate +
-                  ')';
-                params[cdate] = curValue[1];
-                break;
-              } else if (curValue[0] === 'mdate') {
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'user' ||
+                    curValue[0] === 'group' ||
+                    curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther' ||
+                    curValue[0] === 'acRead' ||
+                    curValue[0] === 'acWrite' ||
+                    curValue[0] === 'acFull'))
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const mdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   '(' +
                   ieTable +
-                  '.`mdate` REGEXP @' +
-                  mdate +
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  ' REGEXP @' +
+                  value +
                   ')';
-                params[mdate] = curValue[1];
-                break;
+                params[value] = curValue[1];
               } else {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1151,10 +1738,11 @@ export default class MySQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
                   ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                  ' WHERE `name`=@' +
+                  '.`guid` AND `name`=@' +
                   name +
                   ' AND `string` REGEXP @' +
                   value +
@@ -1165,34 +1753,33 @@ export default class MySQLDriver extends NymphDriver {
               break;
             case 'imatch':
             case '!imatch':
-              if (curValue[0] === 'cdate') {
-                if (curQuery) {
-                  curQuery += typeIsOr ? ' OR ' : ' AND ';
-                }
-                const cdate = `param${++count.i}`;
-                curQuery +=
-                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  '(' +
-                  ieTable +
-                  '.`cdate` REGEXP @' +
-                  cdate +
-                  ')';
-                params[cdate] = curValue[1];
-                break;
-              } else if (curValue[0] === 'mdate') {
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'user' ||
+                    curValue[0] === 'group' ||
+                    curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther' ||
+                    curValue[0] === 'acRead' ||
+                    curValue[0] === 'acWrite' ||
+                    curValue[0] === 'acFull'))
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const mdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   '(' +
                   ieTable +
-                  '.`mdate` REGEXP @' +
-                  mdate +
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  ' REGEXP @' +
+                  value +
                   ')';
-                params[mdate] = curValue[1];
-                break;
+                params[value] = curValue[1];
               } else {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1201,10 +1788,11 @@ export default class MySQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
                   ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                  ' WHERE `name`=@' +
+                  '.`guid` AND `name`=@' +
                   name +
                   ' AND LOWER(`string`) REGEXP LOWER(@' +
                   value +
@@ -1215,34 +1803,33 @@ export default class MySQLDriver extends NymphDriver {
               break;
             case 'like':
             case '!like':
-              if (curValue[0] === 'cdate') {
-                if (curQuery) {
-                  curQuery += typeIsOr ? ' OR ' : ' AND ';
-                }
-                const cdate = `param${++count.i}`;
-                curQuery +=
-                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  '(' +
-                  ieTable +
-                  '.`cdate` LIKE @' +
-                  cdate +
-                  ')';
-                params[cdate] = curValue[1];
-                break;
-              } else if (curValue[0] === 'mdate') {
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'user' ||
+                    curValue[0] === 'group' ||
+                    curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther' ||
+                    curValue[0] === 'acRead' ||
+                    curValue[0] === 'acWrite' ||
+                    curValue[0] === 'acFull'))
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const mdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   '(' +
                   ieTable +
-                  '.`mdate` LIKE @' +
-                  mdate +
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  ' LIKE @' +
+                  value +
                   ')';
-                params[mdate] = curValue[1];
-                break;
+                params[value] = curValue[1];
               } else {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1251,10 +1838,11 @@ export default class MySQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
                   ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                  ' WHERE `name`=@' +
+                  '.`guid` AND `name`=@' +
                   name +
                   ' AND `string` LIKE @' +
                   value +
@@ -1265,34 +1853,33 @@ export default class MySQLDriver extends NymphDriver {
               break;
             case 'ilike':
             case '!ilike':
-              if (curValue[0] === 'cdate') {
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'user' ||
+                    curValue[0] === 'group' ||
+                    curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther' ||
+                    curValue[0] === 'acRead' ||
+                    curValue[0] === 'acWrite' ||
+                    curValue[0] === 'acFull'))
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const cdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   '(' +
                   ieTable +
-                  '.`cdate` LIKE @' +
-                  cdate +
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  ' LIKE @' +
+                  value +
                   ')';
-                params[cdate] = curValue[1];
-                break;
-              } else if (curValue[0] === 'mdate') {
-                if (curQuery) {
-                  curQuery += typeIsOr ? ' OR ' : ' AND ';
-                }
-                const mdate = `param${++count.i}`;
-                curQuery +=
-                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  '(' +
-                  ieTable +
-                  '.`mdate` LIKE @' +
-                  mdate +
-                  ')';
-                params[mdate] = curValue[1];
-                break;
+                params[value] = curValue[1];
               } else {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1301,10 +1888,11 @@ export default class MySQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
                   ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                  ' WHERE `name`=@' +
+                  '.`guid` AND `name`=@' +
                   name +
                   ' AND LOWER(`string`) LIKE LOWER(@' +
                   value +
@@ -1315,34 +1903,33 @@ export default class MySQLDriver extends NymphDriver {
               break;
             case 'gt':
             case '!gt':
-              if (curValue[0] === 'cdate') {
-                if (curQuery) {
-                  curQuery += typeIsOr ? ' OR ' : ' AND ';
-                }
-                const cdate = `param${++count.i}`;
-                curQuery +=
-                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  ieTable +
-                  '.`cdate`>@' +
-                  cdate;
-                params[cdate] = isNaN(Number(curValue[1]))
-                  ? null
-                  : Number(curValue[1]);
-                break;
-              } else if (curValue[0] === 'mdate') {
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'user' ||
+                    curValue[0] === 'group' ||
+                    curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther' ||
+                    curValue[0] === 'acRead' ||
+                    curValue[0] === 'acWrite' ||
+                    curValue[0] === 'acFull'))
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const mdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   ieTable +
-                  '.`mdate`>@' +
-                  mdate;
-                params[mdate] = isNaN(Number(curValue[1]))
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  '>@' +
+                  value;
+                params[value] = isNaN(Number(curValue[1]))
                   ? null
                   : Number(curValue[1]);
-                break;
               } else {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1351,10 +1938,11 @@ export default class MySQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
                   ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                  ' WHERE `name`=@' +
+                  '.`guid` AND `name`=@' +
                   name +
                   ' AND `number`>@' +
                   value +
@@ -1367,34 +1955,33 @@ export default class MySQLDriver extends NymphDriver {
               break;
             case 'gte':
             case '!gte':
-              if (curValue[0] === 'cdate') {
-                if (curQuery) {
-                  curQuery += typeIsOr ? ' OR ' : ' AND ';
-                }
-                const cdate = `param${++count.i}`;
-                curQuery +=
-                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  ieTable +
-                  '.`cdate`>=@' +
-                  cdate;
-                params[cdate] = isNaN(Number(curValue[1]))
-                  ? null
-                  : Number(curValue[1]);
-                break;
-              } else if (curValue[0] === 'mdate') {
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'user' ||
+                    curValue[0] === 'group' ||
+                    curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther' ||
+                    curValue[0] === 'acRead' ||
+                    curValue[0] === 'acWrite' ||
+                    curValue[0] === 'acFull'))
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const mdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   ieTable +
-                  '.`mdate`>=@' +
-                  mdate;
-                params[mdate] = isNaN(Number(curValue[1]))
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  '>=@' +
+                  value;
+                params[value] = isNaN(Number(curValue[1]))
                   ? null
                   : Number(curValue[1]);
-                break;
               } else {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1403,10 +1990,11 @@ export default class MySQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
                   ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                  ' WHERE `name`=@' +
+                  '.`guid` AND `name`=@' +
                   name +
                   ' AND `number`>=@' +
                   value +
@@ -1419,34 +2007,33 @@ export default class MySQLDriver extends NymphDriver {
               break;
             case 'lt':
             case '!lt':
-              if (curValue[0] === 'cdate') {
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'user' ||
+                    curValue[0] === 'group' ||
+                    curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther' ||
+                    curValue[0] === 'acRead' ||
+                    curValue[0] === 'acWrite' ||
+                    curValue[0] === 'acFull'))
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const cdate = `param${++count.i}`;
-                curQuery +=
-                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  ieTable +
-                  '.`cdate`<@' +
-                  cdate;
-                params[cdate] = isNaN(Number(curValue[1]))
-                  ? null
-                  : Number(curValue[1]);
-                break;
-              } else if (curValue[0] === 'mdate') {
-                if (curQuery) {
-                  curQuery += typeIsOr ? ' OR ' : ' AND ';
-                }
-                const mdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   ieTable +
-                  '.`mdate`<@' +
-                  mdate;
-                params[mdate] = isNaN(Number(curValue[1]))
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  '<@' +
+                  value;
+                params[value] = isNaN(Number(curValue[1]))
                   ? null
                   : Number(curValue[1]);
-                break;
               } else {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1455,10 +2042,11 @@ export default class MySQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
                   ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                  ' WHERE `name`=@' +
+                  '.`guid` AND `name`=@' +
                   name +
                   ' AND `number`<@' +
                   value +
@@ -1471,34 +2059,33 @@ export default class MySQLDriver extends NymphDriver {
               break;
             case 'lte':
             case '!lte':
-              if (curValue[0] === 'cdate') {
-                if (curQuery) {
-                  curQuery += typeIsOr ? ' OR ' : ' AND ';
-                }
-                const cdate = `param${++count.i}`;
-                curQuery +=
-                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                  ieTable +
-                  '.`cdate`<=@' +
-                  cdate;
-                params[cdate] = isNaN(Number(curValue[1]))
-                  ? null
-                  : Number(curValue[1]);
-                break;
-              } else if (curValue[0] === 'mdate') {
+              if (
+                curValue[0] === 'cdate' ||
+                curValue[0] === 'mdate' ||
+                (this.nymph.tilmeld != null &&
+                  (curValue[0] === 'user' ||
+                    curValue[0] === 'group' ||
+                    curValue[0] === 'acUser' ||
+                    curValue[0] === 'acGroup' ||
+                    curValue[0] === 'acOther' ||
+                    curValue[0] === 'acRead' ||
+                    curValue[0] === 'acWrite' ||
+                    curValue[0] === 'acFull'))
+              ) {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
                 }
-                const mdate = `param${++count.i}`;
+                const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                   ieTable +
-                  '.`mdate`<=@' +
-                  mdate;
-                params[mdate] = isNaN(Number(curValue[1]))
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  '<=@' +
+                  value;
+                params[value] = isNaN(Number(curValue[1]))
                   ? null
                   : Number(curValue[1]);
-                break;
               } else {
                 if (curQuery) {
                   curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1507,10 +2094,11 @@ export default class MySQLDriver extends NymphDriver {
                 const value = `param${++count.i}`;
                 curQuery +=
                   (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'data_' + etype) +
+                  ' WHERE `guid`=' +
                   ieTable +
-                  '.`guid` IN (SELECT `guid` FROM ' +
-                  MySQLDriver.escape(this.prefix + 'comparisons_' + etype) +
-                  ' WHERE `name`=@' +
+                  '.`guid` AND `name`=@' +
                   name +
                   ' AND `number`<=@' +
                   value +
@@ -1534,32 +2122,66 @@ export default class MySQLDriver extends NymphDriver {
               if (curQuery) {
                 curQuery += typeIsOr ? ' OR ' : ' AND ';
               }
-              const name = `param${++count.i}`;
-              const guid = `param${++count.i}`;
-              curQuery +=
-                (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                ieTable +
-                '.`guid` IN (SELECT `guid` FROM ' +
-                MySQLDriver.escape(this.prefix + 'references_' + etype) +
-                ' WHERE `name`=@' +
-                name +
-                ' AND `reference`=UNHEX(@' +
-                guid +
-                '))';
-              params[name] = curValue[0];
-              params[guid] = curQguid;
+              if (
+                this.nymph.tilmeld != null &&
+                (curValue[0] === 'user' || curValue[0] === 'group')
+              ) {
+                const guid = `param${++count.i}`;
+                curQuery +=
+                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  ieTable +
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  '=UNHEX(@' +
+                  guid +
+                  ')';
+                params[guid] = curQguid;
+              } else if (
+                this.nymph.tilmeld != null &&
+                (curValue[0] === 'acRead' ||
+                  curValue[0] === 'acWrite' ||
+                  curValue[0] === 'acFull')
+              ) {
+                const queryParam = `param${++count.i}`;
+                curQuery +=
+                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'MATCH (' +
+                  ieTable +
+                  '.' +
+                  MySQLDriver.escape(curValue[0]) +
+                  ') AGAINST (@' +
+                  queryParam +
+                  ' IN BOOLEAN MODE)';
+                params[queryParam] = '+' + curQguid;
+              } else {
+                const name = `param${++count.i}`;
+                const guid = `param${++count.i}`;
+                curQuery +=
+                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'references_' + etype) +
+                  ' WHERE `guid`=' +
+                  ieTable +
+                  '.`guid` AND `name`=@' +
+                  name +
+                  ' AND `reference`=UNHEX(@' +
+                  guid +
+                  '))';
+                params[name] = curValue[0];
+                params[guid] = curQguid;
+              }
               break;
             case 'selector':
             case '!selector':
-              const subquery = this.makeEntityQuery(
-                options,
+              const innerquery = this.makeEntityQuery(
+                { ...options, sort: null, limit: undefined },
                 [curValue],
                 etype,
                 count,
                 params,
                 true,
                 tableSuffix,
-                etypes
+                etypes,
               );
               if (curQuery) {
                 curQuery += typeIsOr ? ' OR ' : ' AND ';
@@ -1567,61 +2189,174 @@ export default class MySQLDriver extends NymphDriver {
               curQuery +=
                 (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
                 '(' +
-                subquery.query +
+                innerquery.query +
                 ')';
               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);
-              const qrefQuery = this.makeEntityQuery(
-                { ...qrefOptions, return: 'guid', class: QrefEntityClass },
-                qrefSelectors,
-                QrefEntityClass.ETYPE,
-                count,
-                params,
-                false,
-                makeTableSuffix(),
-                etypes
-              );
               if (curQuery) {
                 curQuery += typeIsOr ? ' OR ' : ' AND ';
               }
-              const qrefName = `param${++count.i}`;
-              curQuery +=
-                (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
-                ieTable +
-                '.`guid` IN (SELECT `guid` FROM ' +
-                MySQLDriver.escape(this.prefix + 'references_' + etype) +
-                ' WHERE `name`=@' +
-                qrefName +
-                ' AND `reference` IN (' +
-                qrefQuery.query +
-                '))';
-              params[qrefName] = curValue[0];
+              if (
+                this.nymph.tilmeld != null &&
+                (curValue[0] === 'user' || curValue[0] === 'group')
+              ) {
+                const qrefQuery = this.makeEntityQuery(
+                  {
+                    ...qrefOptions,
+                    sort: qrefOptions.sort ?? null,
+                    return: 'guid',
+                    class: QrefEntityClass,
+                  },
+                  qrefSelectors,
+                  QrefEntityClass.ETYPE,
+                  count,
+                  params,
+                  false,
+                  makeTableSuffix(),
+                  etypes,
+                  'r' +
+                    referenceTableSuffix +
+                    '.' +
+                    MySQLDriver.escape(curValue[0]),
+                );
+
+                curQuery +=
+                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'entities_' + etype) +
+                  ' r' +
+                  referenceTableSuffix +
+                  ' WHERE r' +
+                  referenceTableSuffix +
+                  '.`guid`=' +
+                  ieTable +
+                  '.`guid` AND EXISTS (' +
+                  qrefQuery.query +
+                  '))';
+              } else if (
+                this.nymph.tilmeld != null &&
+                (curValue[0] === 'acRead' ||
+                  curValue[0] === 'acWrite' ||
+                  curValue[0] === 'acFull')
+              ) {
+                const qrefQuery = this.makeEntityQuery(
+                  {
+                    ...qrefOptions,
+                    sort: qrefOptions.sort ?? null,
+                    return: 'guid',
+                    class: QrefEntityClass,
+                  },
+                  qrefSelectors,
+                  QrefEntityClass.ETYPE,
+                  count,
+                  params,
+                  false,
+                  makeTableSuffix(),
+                  etypes,
+                  undefined,
+                  (guid) =>
+                    ieTable +
+                    '.' +
+                    MySQLDriver.escape(curValue[0]) +
+                    " LIKE CONCAT('% ', LOWER(HEX(" +
+                    guid +
+                    ")), ' %')",
+                );
+
+                curQuery +=
+                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (' +
+                  qrefQuery.query +
+                  ')';
+              } else {
+                const qrefQuery = this.makeEntityQuery(
+                  {
+                    ...qrefOptions,
+                    sort: qrefOptions.sort ?? null,
+                    return: 'guid',
+                    class: QrefEntityClass,
+                  },
+                  qrefSelectors,
+                  QrefEntityClass.ETYPE,
+                  count,
+                  params,
+                  false,
+                  makeTableSuffix(),
+                  etypes,
+                  'r' + referenceTableSuffix + '.`reference`',
+                );
+                const qrefName = `param${++count.i}`;
+                curQuery +=
+                  (xor(typeIsNot, clauseNot) ? 'NOT ' : '') +
+                  'EXISTS (SELECT `guid` FROM ' +
+                  MySQLDriver.escape(this.prefix + 'references_' + etype) +
+                  ' r' +
+                  referenceTableSuffix +
+                  ' WHERE r' +
+                  referenceTableSuffix +
+                  '.`guid`=' +
+                  ieTable +
+                  '.`guid` AND r' +
+                  referenceTableSuffix +
+                  '.`name`=@' +
+                  qrefName +
+                  ' AND EXISTS (' +
+                  qrefQuery.query +
+                  '))';
+                params[qrefName] = curValue[0];
+              }
               break;
           }
         }
         return curQuery;
-      }
+      },
     );
 
     let sortBy: string;
-    switch (sort) {
-      case 'mdate':
-        sortBy = '`mdate`';
-        break;
-      case 'cdate':
-      default:
-        sortBy = '`cdate`';
-        break;
-    }
-    if (options.reverse) {
-      sortBy += ' DESC';
+    let sortByInner: string;
+    let sortJoin = '';
+    let sortJoinInner = '';
+    const order = options.reverse ? ' DESC' : '';
+    if (sort == null) {
+      sortBy = '';
+      sortByInner = '';
+    } else {
+      switch (sort) {
+        case 'mdate':
+          sortBy = `ORDER BY ${eTable}.\`mdate\`${order}`;
+          sortByInner = `ORDER BY ${ieTable}.\`mdate\`${order}`;
+          break;
+        case 'cdate':
+          sortBy = `ORDER BY ${eTable}.\`cdate\`${order}`;
+          sortByInner = `ORDER BY ${ieTable}.\`cdate\`${order}`;
+          break;
+        default:
+          const name = `param${++count.i}`;
+          sortJoin = `LEFT JOIN (
+              SELECT \`guid\`, \`string\`, \`number\`
+              FROM ${MySQLDriver.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 ${MySQLDriver.escape(this.prefix + 'data_' + etype)}
+              WHERE \`name\`=@${name}
+              ORDER BY \`number\`${order}, \`string\`${order}
+            ) ${sTable} ON ${ieTable}.\`guid\`=${sTable}.\`guid\``;
+          sortBy = `ORDER BY ${sTable}.\`number\`${order}, ${sTable}.\`string\`${order}`;
+          sortByInner = sortBy;
+          params[name] = sort;
+          break;
+      }
     }
 
     let query: string;
@@ -1632,31 +2367,36 @@ export default class MySQLDriver 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 = guidExplicitSelector
+          ? `${guidExplicitSelector(`${ieTable}.\`guid\``)} AND `
+          : guidSelector
+            ? `${ieTable}.\`guid\`=${guidSelector} AND `
+            : '';
         if (options.return === 'count') {
           if (limit || offset) {
             query = `SELECT COUNT(${countTable}.\`guid\`) AS \`count\` FROM (
                 SELECT ${ieTable}.\`guid\` AS \`guid\`
                 FROM ${MySQLDriver.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 ${MySQLDriver.escape(
-                `${this.prefix}entities_${etype}`
+                `${this.prefix}entities_${etype}`,
               )} ${ieTable}
-              WHERE (${whereClause})`;
+              WHERE ${guidClause}(${whereClause})`;
           }
         } else if (options.return === 'guid') {
           const guidColumn =
@@ -1665,38 +2405,47 @@ export default class MySQLDriver extends NymphDriver {
               : `${ieTable}.\`guid\``;
           query = `SELECT ${guidColumn} AS \`guid\`
             FROM ${MySQLDriver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} ${ieTable}
-            WHERE (${whereClause})
-            ORDER BY ${ieTable}.${sortBy}${limit}${offset}`;
+            ${sortJoinInner}
+            WHERE ${guidClause}(${whereClause})
+            ${sortByInner ? sortByInner + ', ' : 'ORDER BY '}${ieTable}.\`guid\`${limit}${offset}`;
         } else {
           query = `SELECT
               LOWER(HEX(${eTable}.\`guid\`)) AS \`guid\`,
               ${eTable}.\`tags\`,
               ${eTable}.\`cdate\`,
               ${eTable}.\`mdate\`,
+              LOWER(HEX(${eTable}.\`user\`)) AS \`user\`,
+              LOWER(HEX(${eTable}.\`group\`)) AS \`group\`,
+              ${eTable}.\`acUser\`,
+              ${eTable}.\`acGroup\`,
+              ${eTable}.\`acOther\`,
+              ${eTable}.\`acRead\`,
+              ${eTable}.\`acWrite\`,
+              ${eTable}.\`acFull\`,
               ${dTable}.\`name\`,
               ${dTable}.\`value\`,
-              ${cTable}.\`string\`,
-              ${cTable}.\`number\`
+              ${dTable}.\`json\`,
+              ${dTable}.\`string\`,
+              ${dTable}.\`number\`
             FROM ${MySQLDriver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} ${eTable}
             LEFT JOIN ${MySQLDriver.escape(
-              `${this.prefix}data_${etype}`
+              `${this.prefix}data_${etype}`,
             )} ${dTable} ON ${eTable}.\`guid\`=${dTable}.\`guid\`
-            INNER JOIN ${MySQLDriver.escape(
-              `${this.prefix}comparisons_${etype}`
-            )} ${cTable} ON ${dTable}.\`guid\`=${cTable}.\`guid\` AND ${dTable}.\`name\`=${cTable}.\`name\`
+            ${sortJoin}
             INNER JOIN (
               SELECT ${ieTable}.\`guid\`
               FROM ${MySQLDriver.escape(
-                `${this.prefix}entities_${etype}`
+                `${this.prefix}entities_${etype}`,
               )} ${ieTable}
-              WHERE (${whereClause})
-              ORDER BY ${ieTable}.${sortBy}${limit}${offset}
+              ${sortJoinInner}
+              WHERE ${guidClause}(${whereClause})
+              ${sortByInner}${limit}${offset}
             ) ${fTable} ON ${eTable}.\`guid\`=${fTable}.\`guid\`
-            ORDER BY ${eTable}.${sortBy}`;
+            ${sortBy ? sortBy + ', ' : 'ORDER BY '}${eTable}.\`guid\``;
         }
       }
     } else {
@@ -1706,28 +2455,33 @@ export default class MySQLDriver 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 = guidExplicitSelector
+          ? ` WHERE ${guidExplicitSelector(`${ieTable}.\`guid\``)}`
+          : guidSelector
+            ? ` WHERE ${ieTable}.\`guid\`=${guidSelector}`
+            : '';
         if (options.return === 'count') {
           if (limit || offset) {
             query = `SELECT COUNT(${countTable}.\`guid\`) AS \`count\` FROM (
                 SELECT ${ieTable}.\`guid\` AS \`guid\`
                 FROM ${MySQLDriver.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 ${MySQLDriver.escape(
-                `${this.prefix}entities_${etype}`
-              )} ${ieTable}`;
+                `${this.prefix}entities_${etype}`,
+              )} ${ieTable}${guidClause}`;
           }
         } else if (options.return === 'guid') {
           const guidColumn =
@@ -1736,9 +2490,11 @@ export default class MySQLDriver extends NymphDriver {
               : `${ieTable}.\`guid\``;
           query = `SELECT ${guidColumn} AS \`guid\`
             FROM ${MySQLDriver.escape(
-              `${this.prefix}entities_${etype}`
+              `${this.prefix}entities_${etype}`,
             )} ${ieTable}
-            ORDER BY ${ieTable}.${sortBy}${limit}${offset}`;
+            ${sortJoinInner}
+            ${guidClause}
+            ${sortByInner ? sortByInner + ', ' : 'ORDER BY '}${ieTable}.\`guid\`${limit}${offset}`;
         } else {
           if (limit || offset) {
             query = `SELECT
@@ -1746,47 +2502,64 @@ export default class MySQLDriver extends NymphDriver {
                 ${eTable}.\`tags\`,
                 ${eTable}.\`cdate\`,
                 ${eTable}.\`mdate\`,
+                LOWER(HEX(${eTable}.\`user\`)) AS \`user\`,
+                LOWER(HEX(${eTable}.\`group\`)) AS \`group\`,
+                ${eTable}.\`acUser\`,
+                ${eTable}.\`acGroup\`,
+                ${eTable}.\`acOther\`,
+                ${eTable}.\`acRead\`,
+                ${eTable}.\`acWrite\`,
+                ${eTable}.\`acFull\`,
                 ${dTable}.\`name\`,
                 ${dTable}.\`value\`,
-                ${cTable}.\`string\`,
-                ${cTable}.\`number\`
+                ${dTable}.\`json\`,
+                ${dTable}.\`string\`,
+                ${dTable}.\`number\`
               FROM ${MySQLDriver.escape(
-                `${this.prefix}entities_${etype}`
+                `${this.prefix}entities_${etype}`,
               )} ${eTable}
               LEFT JOIN ${MySQLDriver.escape(
-                `${this.prefix}data_${etype}`
+                `${this.prefix}data_${etype}`,
               )} ${dTable} ON ${eTable}.\`guid\`=${dTable}.\`guid\`
-              INNER JOIN ${MySQLDriver.escape(
-                `${this.prefix}comparisons_${etype}`
-              )} ${cTable} ON ${dTable}.\`guid\`=${cTable}.\`guid\` AND ${dTable}.\`name\`=${cTable}.\`name\`
+              ${sortJoin}
               INNER JOIN (
                 SELECT ${ieTable}.\`guid\`
                 FROM ${MySQLDriver.escape(
-                  `${this.prefix}entities_${etype}`
+                  `${this.prefix}entities_${etype}`,
                 )} ${ieTable}
-                ORDER BY ${ieTable}.${sortBy}${limit}${offset}
+                ${sortJoinInner}
+                ${guidClause}
+                ${sortByInner}${limit}${offset}
               ) ${fTable} ON ${eTable}.\`guid\`=${fTable}.\`guid\`
-              ORDER BY ${eTable}.${sortBy}`;
+              ${sortBy ? sortBy + ', ' : 'ORDER BY '}${eTable}.\`guid\``;
           } else {
             query = `SELECT
                 LOWER(HEX(${eTable}.\`guid\`)) AS \`guid\`,
                 ${eTable}.\`tags\`,
                 ${eTable}.\`cdate\`,
                 ${eTable}.\`mdate\`,
+                LOWER(HEX(${eTable}.\`user\`)) AS \`user\`,
+                LOWER(HEX(${eTable}.\`group\`)) AS \`group\`,
+                ${eTable}.\`acUser\`,
+                ${eTable}.\`acGroup\`,
+                ${eTable}.\`acOther\`,
+                ${eTable}.\`acRead\`,
+                ${eTable}.\`acWrite\`,
+                ${eTable}.\`acFull\`,
                 ${dTable}.\`name\`,
                 ${dTable}.\`value\`,
-                ${cTable}.\`string\`,
-                ${cTable}.\`number\`
+                ${dTable}.\`json\`,
+                ${dTable}.\`string\`,
+                ${dTable}.\`number\`
               FROM ${MySQLDriver.escape(
-                `${this.prefix}entities_${etype}`
+                `${this.prefix}entities_${etype}`,
               )} ${eTable}
               LEFT JOIN ${MySQLDriver.escape(
-                `${this.prefix}data_${etype}`
+                `${this.prefix}data_${etype}`,
               )} ${dTable} ON ${eTable}.\`guid\`=${dTable}.\`guid\`
-              INNER JOIN ${MySQLDriver.escape(
-                `${this.prefix}comparisons_${etype}`
-              )} ${cTable} ON ${dTable}.\`guid\`=${cTable}.\`guid\` AND ${dTable}.\`name\`=${cTable}.\`name\`
-              ORDER BY ${eTable}.${sortBy}`;
+              ${sortJoin}
+              ${guidExplicitSelector ? `WHERE ${guidExplicitSelector(`${eTable}.\`guid\``)}` : guidSelector ? `WHERE ${eTable}.\`guid\`=${guidSelector}` : ''}
+              ${sortBy ? sortBy + ', ' : 'ORDER BY '}${eTable}.\`guid\``;
           }
         }
       }
@@ -1806,38 +2579,18 @@ export default class MySQLDriver extends NymphDriver {
   protected performQuery(
     options: Options,
     formattedSelectors: FormattedSelector[],
-    etype: string
+    etype: string,
   ): {
     result: any;
   } {
     const { query, params, etypes } = this.makeEntityQuery(
       options,
       formattedSelectors,
-      etype
-    );
-    const result = this.queryIter(query, { etypes, params }).then((val) =>
-      val[Symbol.iterator]()
+      etype,
     );
-    return {
-      result,
-    };
-  }
-
-  protected performQuerySync(
-    options: Options,
-    formattedSelectors: FormattedSelector[],
-    etype: string
-  ): {
-    result: any;
-  } {
-    const { query, params, etypes } = this.makeEntityQuery(
-      options,
-      formattedSelectors,
-      etype
+    const result = this.queryArray(query, { etypes, params }).then((val) =>
+      val[Symbol.iterator](),
     );
-    const result = (this.queryIterSync(query, { etypes, params }) || [])[
-      Symbol.iterator
-    ]();
     return {
       result,
     };
@@ -1851,20 +2604,26 @@ export default class MySQLDriver extends NymphDriver {
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
   ): Promise<string[]>;
+  public async getEntities<T extends EntityConstructor = EntityConstructor>(
+    options: Options<T> & { return: 'object' },
+    ...selectors: Selector[]
+  ): Promise<EntityObjectType<T>[]>;
   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>[] | EntityObjectType<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;
@@ -1873,9 +2632,23 @@ export default class MySQLDriver extends NymphDriver {
       (row) => Number(row.count),
       (row) => row.guid,
       (row) => ({
-        tags: row.tags.length > 2 ? row.tags.slice(1, -1).split(' ') : [],
-        cdate: isNaN(Number(row.cdate)) ? null : Number(row.cdate),
-        mdate: isNaN(Number(row.mdate)) ? null : Number(row.mdate),
+        tags:
+          row.tags.length > 2
+            ? row.tags
+                .slice(1, -1)
+                .split(' ')
+                .filter((tag: string) => tag)
+            : [],
+        cdate: isNaN(Number(row.cdate)) ? Date.now() : Number(row.cdate),
+        mdate: isNaN(Number(row.mdate)) ? Date.now() : Number(row.mdate),
+        user: row.user,
+        group: row.group,
+        acUser: row.acUser,
+        acGroup: row.acGroup,
+        acOther: row.acOther,
+        acRead: row.acRead?.slice(1, -1).split(' ') ?? [],
+        acWrite: row.acWrite?.slice(1, -1).split(' ') ?? [],
+        acFull: row.acFull?.slice(1, -1).split(' ') ?? [],
       }),
       (row) => ({
         name: row.name,
@@ -1883,9 +2656,11 @@ export default class MySQLDriver extends NymphDriver {
           row.value === 'N'
             ? JSON.stringify(row.number)
             : row.value === 'S'
-            ? JSON.stringify(row.string)
-            : row.value,
-      })
+              ? JSON.stringify(row.string)
+              : row.value === 'J'
+                ? JSON.stringify(row.json)
+                : row.value,
+      }),
     );
 
     const result = await resultPromise;
@@ -1896,231 +2671,374 @@ export default class MySQLDriver 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.length > 2 ? row.tags.slice(1, -1).split(',') : [],
-        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(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 ${MySQLDriver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} WHERE \`name\`=@name;`,
       {
         params: {
           name: name,
         },
-      }
+      },
     );
     return (result?.cur_uid as number | null) ?? null;
   }
 
-  public async import(filename: string) {
+  public async importEntity(entity: {
+    guid: string;
+    cdate: number;
+    mdate: number;
+    tags: string[];
+    sdata: SerializedEntityData;
+    etype: string;
+  }) {
+    return await this.importEntityInternal(entity);
+  }
+
+  public async importEntityTokens(entity: {
+    guid: string;
+    cdate: number;
+    mdate: number;
+    tags: string[];
+    sdata: SerializedEntityData;
+    etype: string;
+  }) {
+    return await this.importEntityInternal(entity, { only: 'tokens' });
+  }
+
+  public async importEntityTilmeldAC(entity: {
+    guid: string;
+    cdate: number;
+    mdate: number;
+    tags: string[];
+    sdata: SerializedEntityData;
+    etype: string;
+  }) {
+    return await this.importEntityInternal(entity, { only: 'tilmeldAC' });
+  }
+
+  private async importEntityInternal(
+    {
+      guid,
+      cdate,
+      mdate,
+      tags,
+      sdata,
+      etype,
+    }: {
+      guid: string;
+      cdate: number;
+      mdate: number;
+      tags: string[];
+      sdata: SerializedEntityData;
+      etype: string;
+    },
+    { only = undefined }: { only?: 'tokens' | 'tilmeldAC' } = {},
+  ) {
     try {
-      const result = await this.importFromFile(
-        filename,
-        async (guid, tags, sdata, etype) => {
-          await this.queryRun(
-            `REPLACE INTO ${MySQLDriver.escape(
-              `${this.prefix}entities_${etype}`
-            )} (\`guid\`, \`tags\`, \`cdate\`, \`mdate\`) VALUES (UNHEX(@guid), @tags, @cdate, @mdate);`,
+      let promises = [];
+      if (only == null) {
+        promises.push(
+          this.queryRun(
+            `DELETE FROM ${MySQLDriver.escape(
+              `${this.prefix}entities_${etype}`,
+            )} WHERE \`guid\`=UNHEX(@guid);`,
             {
               etypes: [etype],
               params: {
                 guid,
-                tags: ' ' + tags.join(' ') + ' ',
-                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)),
               },
-            }
-          );
-          const promises = [];
-          promises.push(
-            this.queryRun(
-              `DELETE FROM ${MySQLDriver.escape(
-                `${this.prefix}data_${etype}`
-              )} WHERE \`guid\`=UNHEX(@guid);`,
-              {
-                etypes: [etype],
-                params: {
-                  guid,
-                },
-              }
-            )
-          );
-          promises.push(
-            this.queryRun(
-              `DELETE FROM ${MySQLDriver.escape(
-                `${this.prefix}comparisons_${etype}`
-              )} WHERE \`guid\`=UNHEX(@guid);`,
-              {
-                etypes: [etype],
-                params: {
-                  guid,
-                },
-              }
-            )
-          );
+            },
+          ),
+        );
+        promises.push(
+          this.queryRun(
+            `DELETE FROM ${MySQLDriver.escape(
+              `${this.prefix}data_${etype}`,
+            )} WHERE \`guid\`=UNHEX(@guid);`,
+            {
+              etypes: [etype],
+              params: {
+                guid,
+              },
+            },
+          ),
+        );
+        promises.push(
+          this.queryRun(
+            `DELETE FROM ${MySQLDriver.escape(
+              `${this.prefix}references_${etype}`,
+            )} WHERE \`guid\`=UNHEX(@guid);`,
+            {
+              etypes: [etype],
+              params: {
+                guid,
+              },
+            },
+          ),
+        );
+      }
+      if (only == null || only === 'tokens') {
+        promises.push(
+          this.queryRun(
+            `DELETE FROM ${MySQLDriver.escape(
+              `${this.prefix}tokens_${etype}`,
+            )} WHERE \`guid\`=UNHEX(@guid);`,
+            {
+              etypes: [etype],
+              params: {
+                guid,
+              },
+            },
+          ),
+        );
+      }
+      if (only == null) {
+        promises.push(
+          this.queryRun(
+            `DELETE FROM ${MySQLDriver.escape(
+              `${this.prefix}uniques_${etype}`,
+            )} WHERE \`guid\`=UNHEX(@guid);`,
+            {
+              etypes: [etype],
+              params: {
+                guid,
+              },
+            },
+          ),
+        );
+      }
+
+      await Promise.all(promises);
+      promises = [];
+
+      if (only == null) {
+        let { user, group, acUser, acGroup, acOther, acRead, acWrite, acFull } =
+          this.removeAndReturnACValues(etype, {}, sdata);
+
+        await this.queryRun(
+          `INSERT INTO ${MySQLDriver.escape(
+            `${this.prefix}entities_${etype}`,
+          )} (\`guid\`, \`tags\`, \`cdate\`, \`mdate\`, \`user\`, \`group\`, \`acUser\`, \`acGroup\`, \`acOther\`, \`acRead\`, \`acWrite\`, \`acFull\`) VALUES (UNHEX(@guid), @tags, @cdate, @mdate, ${user == null ? '@user' : 'UNHEX(@user)'}, ${group == null ? '@group' : 'UNHEX(@group)'}, @acUser, @acGroup, @acOther, @acRead, @acWrite, @acFull);`,
+          {
+            etypes: [etype],
+            params: {
+              guid,
+              tags: ' ' + tags.join(' ') + ' ',
+              cdate: isNaN(cdate) ? null : cdate,
+              mdate: isNaN(mdate) ? null : mdate,
+              user,
+              group,
+              acUser,
+              acGroup,
+              acOther,
+              acRead: acRead && ' ' + acRead.join(' ') + ' ',
+              acWrite: acWrite && ' ' + acWrite.join(' ') + ' ',
+              acFull: acFull && ' ' + acFull.join(' ') + ' ',
+            },
+          },
+        );
+
+        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' ? value : null;
+
           promises.push(
             this.queryRun(
-              `DELETE FROM ${MySQLDriver.escape(
-                `${this.prefix}references_${etype}`
-              )} WHERE \`guid\`=UNHEX(@guid);`,
+              `INSERT INTO ${MySQLDriver.escape(
+                `${this.prefix}data_${etype}`,
+              )} (\`guid\`, \`name\`, \`value\`, \`json\`, \`string\`, \`number\`, \`truthy\`) VALUES (UNHEX(@guid), @name, @storageValue, @jsonValue, @string, @number, @truthy);`,
               {
                 etypes: [etype],
                 params: {
                   guid,
+                  name,
+                  storageValue,
+                  jsonValue,
+                  string: storageValue === 'J' ? null : `${uvalue}`,
+                  number: isNaN(Number(uvalue)) ? null : Number(uvalue),
+                  truthy: !!uvalue,
                 },
-              }
-            )
+              },
+            ),
           );
-          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 = [];
+
+          const references = this.findReferences(value);
+          for (const reference of references) {
             promises.push(
               this.queryRun(
                 `INSERT INTO ${MySQLDriver.escape(
-                  `${this.prefix}data_${etype}`
-                )} (\`guid\`, \`name\`, \`value\`) VALUES (UNHEX(@guid), @name, @storageValue);`,
+                  `${this.prefix}references_${etype}`,
+                )} (\`guid\`, \`name\`, \`reference\`) VALUES (UNHEX(@guid), @name, UNHEX(@reference));`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                     name,
-                    storageValue,
+                    reference,
                   },
-                }
-              )
+                },
+              ),
             );
-            promises.push(
-              this.queryRun(
-                `INSERT INTO ${MySQLDriver.escape(
-                  `${this.prefix}comparisons_${etype}`
-                )} (\`guid\`, \`name\`, \`truthy\`, \`string\`, \`number\`) VALUES (UNHEX(@guid), @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) {
+          }
+        }
+      }
+
+      if (only === 'tilmeldAC') {
+        let { user, group, acUser, acGroup, acOther, acRead, acWrite, acFull } =
+          this.removeAndReturnACValues(etype, {}, sdata);
+
+        promises.push(
+          this.queryRun(
+            `UPDATE ${MySQLDriver.escape(
+              `${this.prefix}entities_${etype}`,
+            )} SET \`user\`=${user == null ? '@user' : 'UNHEX(@user)'}, \`group\`=${group == null ? '@group' : 'UNHEX(@group)'}, \`acUser\`=@acUser, \`acGroup\`=@acGroup, \`acOther\`=@acOther, \`acRead\`=@acRead, \`acWrite\`=@acWrite, \`acFull\`=@acFull WHERE \`guid\`=UNHEX(@guid);`,
+            {
+              etypes: [etype],
+              params: {
+                user,
+                group,
+                acUser,
+                acGroup,
+                acOther,
+                acRead: acRead && ' ' + acRead.join(' ') + ' ',
+                acWrite: acWrite && ' ' + acWrite.join(' ') + ' ',
+                acFull: acFull && ' ' + acFull.join(' ') + ' ',
+                guid,
+              },
+            },
+          ),
+        );
+      }
+
+      const EntityClass = this.nymph.getEntityClassByEtype(etype);
+
+      if (only == null || only === 'tokens') {
+        for (let name in sdata) {
+          let tokenString: string | null = null;
+          try {
+            tokenString = EntityClass.getFTSText(name, JSON.parse(sdata[name]));
+          } catch (e: any) {
+            // Ignore error.
+          }
+
+          if (tokenString != null) {
+            const tokens = this.tokenizer.tokenize(tokenString);
+            while (tokens.length) {
+              const currentTokens = tokens.splice(0, 100);
+              const params: { [k: string]: any } = {
+                guid,
+                name,
+              };
+              const values: string[] = [];
+
+              for (let i = 0; i < currentTokens.length; i++) {
+                const token = currentTokens[i];
+                params['token' + i] = token.token;
+                params['position' + i] = token.position;
+                params['stem' + i] = token.stem;
+                values.push(
+                  '(UNHEX(@guid), @name, @token' +
+                    i +
+                    ', @position' +
+                    i +
+                    ', @stem' +
+                    i +
+                    ')',
+                );
+              }
+
               promises.push(
                 this.queryRun(
                   `INSERT INTO ${MySQLDriver.escape(
-                    `${this.prefix}references_${etype}`
-                  )} (\`guid\`, \`name\`, \`reference\`) VALUES (UNHEX(@guid), @name, UNHEX(@reference));`,
+                    `${this.prefix}tokens_${etype}`,
+                  )} (\`guid\`, \`name\`, \`token\`, \`position\`, \`stem\`) VALUES ${values.join(', ')};`,
                   {
                     etypes: [etype],
-                    params: {
-                      guid,
-                      name,
-                      reference,
-                    },
-                  }
-                )
+                    params,
+                  },
+                ),
               );
             }
           }
-          await Promise.all(promises);
-        },
-        async (name, curUid) => {
-          await this.queryRun(
-            `INSERT INTO ${MySQLDriver.escape(
-              `${this.prefix}uids`
-            )} (\`name\`, \`cur_uid\`) VALUES (@name, @curUid) ON DUPLICATE KEY UPDATE \`cur_uid\`=@curUid;`,
-            {
-              params: {
-                name,
-                curUid,
+        }
+      }
+
+      if (only == null) {
+        const uniques = await EntityClass.getUniques({
+          guid,
+          cdate,
+          mdate,
+          tags,
+          data: {},
+          sdata,
+        });
+        for (const unique of uniques) {
+          promises.push(
+            this.queryRun(
+              `INSERT INTO ${MySQLDriver.escape(
+                `${this.prefix}uniques_${etype}`,
+              )} (\`guid\`, \`unique\`) VALUES (UNHEX(@guid), @unique);`,
+              {
+                etypes: [etype],
+                params: {
+                  guid,
+                  unique,
+                },
               },
-            }
+            ).catch((e: any) => {
+              if (e instanceof EntityUniqueConstraintError) {
+                this.nymph.config.debugError(
+                  'mysql',
+                  `Import entity unique constraint violation for GUID "${guid}" on etype "${etype}": "${unique}"`,
+                );
+              }
+              return e;
+            }),
           );
-        },
-        async () => {
-          await this.internalTransaction('nymph-import');
-        },
-        async () => {
-          await this.commit('nymph-import');
         }
-      );
+      }
 
-      return result;
+      await Promise.all(promises);
     } catch (e: any) {
-      await this.rollback('nymph-import');
-      return false;
+      this.nymph.config.debugError('mysql', `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(
+        `INSERT INTO ${MySQLDriver.escape(
+          `${this.prefix}uids`,
+        )} (\`name\`, \`cur_uid\`) VALUES (@name, @value) ON DUPLICATE KEY UPDATE \`cur_uid\`=@value;`,
+        {
+          params: {
+            name,
+            value,
+          },
+        },
+      );
+      await this.commit(`nymph-import-uid-${name}`);
+    } catch (e: any) {
+      this.nymph.config.debugError('mysql', `Import UID error: "${e}"`);
+      await this.rollback(`nymph-import-uid-${name}`);
+      throw e;
     }
   }
 
@@ -2129,55 +3047,57 @@ export default class MySQLDriver extends NymphDriver {
       throw new InvalidParametersError('Name not given for UID.');
     }
     await this.internalTransaction('nymph-newuid');
+    let curUid: number | null = null;
     try {
       const lock = await this.queryGet(
         `SELECT GET_LOCK(${MySQLDriver.escapeValue(
-          `${this.prefix}uids_${name}`
-        )}, 10) AS \`lock\`;`
+          `${this.prefix}uids_${name}`,
+        )}, 10) AS \`lock\`;`,
       );
       if (lock.lock !== 1) {
         throw new QueryFailedError("Couldn't get lock for UID: " + name);
       }
-      let curUid: number | null = null;
       await this.queryRun(
         `INSERT INTO ${MySQLDriver.escape(
-          `${this.prefix}uids`
+          `${this.prefix}uids`,
         )} (\`name\`, \`cur_uid\`) VALUES (@name, 1) ON DUPLICATE KEY UPDATE \`cur_uid\`=\`cur_uid\`+1;`,
         {
           params: {
             name,
           },
-        }
+        },
       );
       const result = await this.queryGet(
         `SELECT \`cur_uid\` FROM ${MySQLDriver.escape(
-          `${this.prefix}uids`
+          `${this.prefix}uids`,
         )} WHERE \`name\`=@name;`,
         {
           params: {
             name,
           },
-        }
+        },
       );
       await this.queryRun(
         `SELECT RELEASE_LOCK(${MySQLDriver.escapeValue(
-          `${this.prefix}uids_${name}`
-        )});`
+          `${this.prefix}uids_${name}`,
+        )});`,
       );
-      await this.commit('nymph-newuid');
       curUid = result.cur_uid ?? null;
-      return curUid;
     } catch (e: any) {
+      this.nymph.config.debugError('mysql', `New UID error: "${e}"`);
       if (e?.message !== "Couldn't get lock for UID: " + name) {
         await this.queryRun(
           `SELECT RELEASE_LOCK(${MySQLDriver.escapeValue(
-            `${this.prefix}uids_${name}`
-          )});`
+            `${this.prefix}uids_${name}`,
+          )});`,
         );
       }
       await this.rollback('nymph-newuid');
       throw e;
     }
+
+    await this.commit('nymph-newuid');
+    return curUid;
   }
 
   public async renameUID(oldName: string, newName: string) {
@@ -2186,14 +3106,14 @@ export default class MySQLDriver extends NymphDriver {
     }
     await this.queryRun(
       `UPDATE ${MySQLDriver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} SET \`name\`=@newName WHERE \`name\`=@oldName;`,
       {
         params: {
           newName,
           oldName,
         },
-      }
+      },
     );
     return true;
   }
@@ -2201,7 +3121,7 @@ export default class MySQLDriver 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) {
@@ -2226,12 +3146,15 @@ export default class MySQLDriver extends NymphDriver {
       guid: string,
       data: EntityData,
       sdata: SerializedEntityData,
-      etype: string
+      uniques: string[],
+      etype: string,
     ) => {
+      const EntityClass = this.nymph.getEntityClassByEtype(etype);
+
       const runInsertQuery = async (
         name: string,
         value: any,
-        svalue: string
+        svalue: string,
       ) => {
         if (value === undefined) {
           return;
@@ -2240,47 +3163,38 @@ export default class MySQLDriver extends NymphDriver {
           typeof value === 'number'
             ? 'N'
             : typeof value === 'string'
-            ? 'S'
-            : svalue;
+              ? 'S'
+              : 'J';
+        const jsonValue = storageValue === 'J' ? svalue : null;
+
         const promises = [];
+
         promises.push(
           this.queryRun(
             `INSERT INTO ${MySQLDriver.escape(
-              `${this.prefix}data_${etype}`
-            )} (\`guid\`, \`name\`, \`value\`) VALUES (UNHEX(@guid), @name, @storageValue);`,
+              `${this.prefix}data_${etype}`,
+            )} (\`guid\`, \`name\`, \`value\`, \`json\`, \`string\`, \`number\`, \`truthy\`) VALUES (UNHEX(@guid), @name, @storageValue, @jsonValue, @string, @number, @truthy);`,
             {
               etypes: [etype],
               params: {
                 guid,
                 name,
                 storageValue,
-              },
-            }
-          )
-        );
-        promises.push(
-          this.queryRun(
-            `INSERT INTO ${MySQLDriver.escape(
-              `${this.prefix}comparisons_${etype}`
-            )} (\`guid\`, \`name\`, \`truthy\`, \`string\`, \`number\`) VALUES (UNHEX(@guid), @name, @truthy, @string, @number);`,
-            {
-              etypes: [etype],
-              params: {
-                guid,
-                name,
-                truthy: !!value,
-                string: `${value}`,
+                jsonValue,
+                string: storageValue === 'J' ? null : `${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 ${MySQLDriver.escape(
-                `${this.prefix}references_${etype}`
+                `${this.prefix}references_${etype}`,
               )} (\`guid\`, \`name\`, \`reference\`) VALUES (UNHEX(@guid), @name, UNHEX(@reference));`,
               {
                 etypes: [etype],
@@ -2289,12 +3203,85 @@ export default class MySQLDriver extends NymphDriver {
                   name,
                   reference,
                 },
-              }
-            )
+              },
+            ),
           );
         }
+
+        let tokenString: string | null = null;
+        try {
+          tokenString = EntityClass.getFTSText(name, value);
+        } catch (e: any) {
+          // Ignore error.
+        }
+
+        if (tokenString != null) {
+          const tokens = this.tokenizer.tokenize(tokenString);
+          while (tokens.length) {
+            const currentTokens = tokens.splice(0, 100);
+            const params: { [k: string]: any } = {
+              guid,
+              name,
+            };
+            const values: string[] = [];
+
+            for (let i = 0; i < currentTokens.length; i++) {
+              const token = currentTokens[i];
+              params['token' + i] = token.token;
+              params['position' + i] = token.position;
+              params['stem' + i] = token.stem;
+              values.push(
+                '(UNHEX(@guid), @name, @token' +
+                  i +
+                  ', @position' +
+                  i +
+                  ', @stem' +
+                  i +
+                  ')',
+              );
+            }
+
+            promises.push(
+              this.queryRun(
+                `INSERT INTO ${MySQLDriver.escape(
+                  `${this.prefix}tokens_${etype}`,
+                )} (\`guid\`, \`name\`, \`token\`, \`position\`, \`stem\`) VALUES ${values.join(', ')};`,
+                {
+                  etypes: [etype],
+                  params,
+                },
+              ),
+            );
+          }
+        }
+
         await Promise.all(promises);
       };
+
+      for (const unique of uniques) {
+        try {
+          await this.queryRun(
+            `INSERT INTO ${MySQLDriver.escape(
+              `${this.prefix}uniques_${etype}`,
+            )} (\`guid\`, \`unique\`) VALUES (UNHEX(@guid), @unique);`,
+            {
+              etypes: [etype],
+              params: {
+                guid,
+                unique,
+              },
+            },
+          );
+        } catch (e: any) {
+          if (e instanceof EntityUniqueConstraintError) {
+            this.nymph.config.debugError(
+              'mysql',
+              `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]));
       }
@@ -2302,109 +3289,185 @@ export default class MySQLDriver 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
+          ) {
+            throw new EntityInvalidDataError('Entity contains no data.');
+          }
+          let processedData = this.removeAndReturnACValues(
+            etype,
+            { ...data },
+            { ...sdata },
+          );
+          ({ data, sdata } = processedData);
+          let {
+            user,
+            group,
+            acUser,
+            acGroup,
+            acOther,
+            acRead,
+            acWrite,
+            acFull,
+          } = processedData;
           await this.queryRun(
             `INSERT INTO ${MySQLDriver.escape(
-              `${this.prefix}entities_${etype}`
-            )} (\`guid\`, \`tags\`, \`cdate\`, \`mdate\`) VALUES (UNHEX(@guid), @tags, @cdate, @cdate);`,
+              `${this.prefix}entities_${etype}`,
+            )} (\`guid\`, \`tags\`, \`cdate\`, \`mdate\`, \`user\`, \`group\`, \`acUser\`, \`acGroup\`, \`acOther\`, \`acRead\`, \`acWrite\`, \`acFull\`) VALUES (UNHEX(@guid), @tags, @cdate, @cdate, ${user == null ? '@user' : 'UNHEX(@user)'}, ${group == null ? '@group' : 'UNHEX(@group)'}, @acUser, @acGroup, @acOther, @acRead, @acWrite, @acFull);`,
             {
               etypes: [etype],
               params: {
                 guid,
                 tags: ' ' + tags.join(' ') + ' ',
                 cdate,
+                user,
+                group,
+                acUser,
+                acGroup,
+                acOther,
+                acRead: acRead && ' ' + acRead.join(' ') + ' ',
+                acWrite: acWrite && ' ' + acWrite.join(' ') + ' ',
+                acFull: acFull && ' ' + acFull.join(' ') + ' ',
               },
-            }
+            },
           );
-          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
+          ) {
+            throw new EntityInvalidDataError('Entity contains no data.');
+          }
+          let processedData = this.removeAndReturnACValues(
+            etype,
+            { ...data },
+            { ...sdata },
+          );
+          ({ data, sdata } = processedData);
+          let {
+            user,
+            group,
+            acUser,
+            acGroup,
+            acOther,
+            acRead,
+            acWrite,
+            acFull,
+          } = processedData;
           if (this.config.rowLocking) {
             const promises = [];
             promises.push(
               this.queryRun(
                 `SELECT 1 FROM ${MySQLDriver.escape(
-                  `${this.prefix}entities_${etype}`
+                  `${this.prefix}entities_${etype}`,
                 )} WHERE \`guid\`=UNHEX(@guid) GROUP BY 1 FOR UPDATE;`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                   },
-                }
-              )
+                },
+              ),
             );
             promises.push(
               this.queryRun(
                 `SELECT 1 FROM ${MySQLDriver.escape(
-                  `${this.prefix}data_${etype}`
+                  `${this.prefix}data_${etype}`,
                 )} WHERE \`guid\`=UNHEX(@guid) GROUP BY 1 FOR UPDATE;`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                   },
-                }
-              )
+                },
+              ),
             );
             promises.push(
               this.queryRun(
                 `SELECT 1 FROM ${MySQLDriver.escape(
-                  `${this.prefix}comparisons_${etype}`
+                  `${this.prefix}references_${etype}`,
                 )} WHERE \`guid\`=UNHEX(@guid) GROUP BY 1 FOR UPDATE;`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                   },
-                }
-              )
+                },
+              ),
             );
             promises.push(
               this.queryRun(
                 `SELECT 1 FROM ${MySQLDriver.escape(
-                  `${this.prefix}references_${etype}`
+                  `${this.prefix}tokens_${etype}`,
                 )} WHERE \`guid\`=UNHEX(@guid) GROUP BY 1 FOR UPDATE;`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                   },
-                }
-              )
+                },
+              ),
+            );
+            promises.push(
+              this.queryRun(
+                `SELECT 1 FROM ${MySQLDriver.escape(
+                  `${this.prefix}uniques_${etype}`,
+                )} WHERE \`guid\`=UNHEX(@guid) GROUP BY 1 FOR UPDATE;`,
+                {
+                  etypes: [etype],
+                  params: {
+                    guid,
+                  },
+                },
+              ),
             );
             await Promise.all(promises);
           }
           if (this.config.tableLocking) {
             await this.queryRun(
               `LOCK TABLES ${MySQLDriver.escape(
-                `${this.prefix}entities_${etype}`
+                `${this.prefix}entities_${etype}`,
+              )} WRITE, ${MySQLDriver.escape(
+                `${this.prefix}data_${etype}`,
               )} WRITE, ${MySQLDriver.escape(
-                `${this.prefix}data_${etype}`
+                `${this.prefix}references_${etype}`,
               )} WRITE, ${MySQLDriver.escape(
-                `${this.prefix}comparisons_${etype}`
+                `${this.prefix}tokens_${etype}`,
               )} WRITE, ${MySQLDriver.escape(
-                `${this.prefix}references_${etype}`
-              )} WRITE;`
+                `${this.prefix}uniques_${etype}`,
+              )} WRITE;`,
             );
           }
           const info = await this.queryRun(
             `UPDATE ${MySQLDriver.escape(
-              `${this.prefix}entities_${etype}`
-            )} SET \`tags\`=@tags, \`mdate\`=@mdate WHERE \`guid\`=UNHEX(@guid) AND \`mdate\` <= @emdate;`,
+              `${this.prefix}entities_${etype}`,
+            )} SET \`tags\`=@tags, \`mdate\`=@mdate, \`user\`=${user == null ? '@user' : 'UNHEX(@user)'}, \`group\`=${group == null ? '@group' : 'UNHEX(@group)'}, \`acUser\`=@acUser, \`acGroup\`=@acGroup, \`acOther\`=@acOther, \`acRead\`=@acRead, \`acWrite\`=@acWrite, \`acFull\`=@acFull WHERE \`guid\`=UNHEX(@guid) AND \`mdate\` <= @emdate;`,
             {
               etypes: [etype],
               params: {
                 tags: ' ' + tags.join(' ') + ' ',
                 mdate,
+                user,
+                group,
+                acUser,
+                acGroup,
+                acOther,
+                acRead: acRead && ' ' + acRead.join(' ') + ' ',
+                acWrite: acWrite && ' ' + acWrite.join(' ') + ' ',
+                acFull: acFull && ' ' + acFull.join(' ') + ' ',
                 guid,
                 emdate: isNaN(Number(entity.mdate)) ? 0 : Number(entity.mdate),
               },
-            }
+            },
           );
           let success = false;
           if (info.changes === 1) {
@@ -2412,67 +3475,92 @@ export default class MySQLDriver extends NymphDriver {
             promises.push(
               this.queryRun(
                 `DELETE FROM ${MySQLDriver.escape(
-                  `${this.prefix}data_${etype}`
+                  `${this.prefix}data_${etype}`,
                 )} WHERE \`guid\`=UNHEX(@guid);`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                   },
-                }
-              )
+                },
+              ),
             );
             promises.push(
               this.queryRun(
                 `DELETE FROM ${MySQLDriver.escape(
-                  `${this.prefix}comparisons_${etype}`
+                  `${this.prefix}references_${etype}`,
                 )} WHERE \`guid\`=UNHEX(@guid);`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                   },
-                }
-              )
+                },
+              ),
             );
             promises.push(
               this.queryRun(
                 `DELETE FROM ${MySQLDriver.escape(
-                  `${this.prefix}references_${etype}`
+                  `${this.prefix}tokens_${etype}`,
                 )} WHERE \`guid\`=UNHEX(@guid);`,
                 {
                   etypes: [etype],
                   params: {
                     guid,
                   },
-                }
-              )
+                },
+              ),
+            );
+            promises.push(
+              this.queryRun(
+                `DELETE FROM ${MySQLDriver.escape(
+                  `${this.prefix}uniques_${etype}`,
+                )} WHERE \`guid\`=UNHEX(@guid);`,
+                {
+                  etypes: [etype],
+                  params: {
+                    guid,
+                  },
+                },
+              ),
             );
             await Promise.all(promises);
-            await insertData(guid, data, sdata, etype);
+            await insertData(guid, data, sdata, uniques, etype);
             success = true;
           }
           if (this.config.tableLocking) {
             await this.queryRun('UNLOCK TABLES;');
           }
+          if (!success && info.changes === 0) {
+            throw new EntityConflictError(
+              "Entity either doesn't exist or is newer in the DB.",
+            );
+          }
           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) {
+              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('mysql', `Save entity error: "${e}"`);
+      if (inTransaction) {
+        await this.rollback('nymph-save');
+      }
       throw e;
     }
   }
@@ -2483,56 +3571,209 @@ export default class MySQLDriver extends NymphDriver {
     }
     await this.queryRun(
       `INSERT INTO ${MySQLDriver.escape(
-        `${this.prefix}uids`
+        `${this.prefix}uids`,
       )} (\`name\`, \`cur_uid\`) VALUES (@name, @curUid) ON DUPLICATE KEY UPDATE \`cur_uid\`=@curUid;`,
       {
         params: {
           name,
           curUid,
         },
-      }
+      },
     );
     return true;
   }
 
-  private async internalTransaction(name: string) {
+  protected async internalTransaction(name: string, setOnSelf = true) {
     if (name == null || typeof name !== 'string' || name.length === 0) {
       throw new InvalidParametersError(
-        'Transaction start attempted without a name.'
+        'Transaction start attempted without a name.',
       );
     }
 
-    if (!this.transaction || this.transaction.count === 0) {
+    let transaction = this.transaction;
+
+    if (!transaction) {
       // Lock to one connection.
-      this.transaction = {
+      transaction = {
         count: 0,
         connection: await this.getConnection(),
+        latestPromise: Promise.resolve(),
       };
-      if (this.config.transactions) {
-        // We're not in a transaction yet, so start one.
-        await this.queryRun('START TRANSACTION;');
+      if (setOnSelf) {
+        this.transaction = transaction;
       }
     }
 
-    if (this.config.transactions) {
-      await this.queryRun(`SAVEPOINT ${MySQLDriver.escape(name)};`);
+    if (this.config.transactions && transaction.count === 0) {
+      // We're not in a transaction yet, so start one.
+      await this.queryRun('START TRANSACTION;', { transaction });
     }
 
-    this.transaction.count++;
+    transaction.count++;
+
+    if (this.config.transactions) {
+      await this.queryRun(`SAVEPOINT ${MySQLDriver.escape(name)};`, {
+        transaction,
+      });
+    }
 
-    return this.transaction;
+    return transaction;
   }
 
   public async startTransaction(name: string) {
-    const inTransaction = this.inTransaction();
-    const transaction = await this.internalTransaction(name);
-    if (!inTransaction) {
-      this.transaction = null;
-    }
+    const transaction = await this.internalTransaction(name, false);
 
     const nymph = this.nymph.clone();
     (nymph.driver as MySQLDriver).transaction = transaction;
 
     return nymph;
   }
+
+  private async removeTilmeldOldRows(etype: string) {
+    await this.internalTransaction('nymph-remove-tilmeld-rows');
+    try {
+      for (let name of [
+        'user',
+        'group',
+        'acUser',
+        'acGroup',
+        'acOther',
+        'acRead',
+        'acWrite',
+        'acFull',
+      ]) {
+        await this.queryRun(
+          `DELETE FROM ${MySQLDriver.escape(
+            `${this.prefix}data_${etype}`,
+          )} WHERE \`name\`=@name;`,
+          {
+            etypes: [etype],
+            params: {
+              name,
+            },
+          },
+        );
+        await this.queryRun(
+          `DELETE FROM ${MySQLDriver.escape(
+            `${this.prefix}references_${etype}`,
+          )} WHERE \`name\`=@name;`,
+          {
+            etypes: [etype],
+            params: {
+              name,
+            },
+          },
+        );
+        await this.queryRun(
+          `DELETE FROM ${MySQLDriver.escape(
+            `${this.prefix}tokens_${etype}`,
+          )} WHERE \`name\`=@name;`,
+          {
+            etypes: [etype],
+            params: {
+              name,
+            },
+          },
+        );
+      }
+    } catch (e: any) {
+      this.nymph.config.debugError(
+        'mysql',
+        `Remove tilmeld rows error: "${e}"`,
+      );
+      await this.rollback('nymph-remove-tilmeld-rows');
+      throw e;
+    }
+
+    await this.commit('nymph-remove-tilmeld-rows');
+    return true;
+  }
+
+  public async needsMigration(): Promise<
+    'json' | 'tokens' | 'tilmeldColumns' | false
+  > {
+    const table = await this.queryGet(
+      'SELECT `table_name` AS `table_name` FROM `information_schema`.`tables` WHERE `table_schema`=@db 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_schema`=@db AND `table_name`=@table AND `column_name`='json';",
+        {
+          params: {
+            db: this.config.database,
+            table: table.table_name,
+          },
+        },
+      );
+      if (!result?.exists) {
+        return 'json';
+      }
+    }
+    const table2 = await this.queryGet(
+      'SELECT `table_name` AS `table_name` FROM `information_schema`.`tables` WHERE `table_schema`=@db AND `table_name` LIKE @tokenTable LIMIT 1;',
+      {
+        params: {
+          db: this.config.database,
+          tokenTable: this.prefix + 'tokens_' + '%',
+        },
+      },
+    );
+    if (!table2 || !table2.table_name) {
+      return 'tokens';
+    }
+    const table3 = await this.queryGet(
+      'SELECT `table_name` AS `table_name` FROM `information_schema`.`tables` WHERE `table_schema`=@db AND `table_name` LIKE @prefix LIMIT 1;',
+      {
+        params: {
+          db: this.config.database,
+          prefix: this.prefix + 'entities_' + '%',
+        },
+      },
+    );
+    if (table3?.table_name) {
+      const result = await this.queryGet(
+        "SELECT 1 AS `exists` FROM `information_schema`.`columns` WHERE `table_schema`=@db AND `table_name`=@table AND `column_name`='user';",
+        {
+          params: {
+            db: this.config.database,
+            table: table3.table_name,
+          },
+        },
+      );
+      if (!result?.exists) {
+        return 'tilmeldColumns';
+      }
+    }
+    return false;
+  }
+
+  public async liveMigration(
+    migrationType: 'tokenTables' | 'tilmeldColumns' | 'tilmeldRemoveOldRows',
+  ) {
+    if (migrationType === 'tokenTables') {
+      const etypes = await this.getEtypes();
+
+      for (let etype of etypes) {
+        await this.createTokensTable(etype);
+      }
+    } else if (migrationType === 'tilmeldColumns') {
+      const etypes = await this.getEtypes();
+
+      for (let etype of etypes) {
+        await this.addTilmeldColumnsAndIndexes(etype);
+      }
+    } else if (migrationType === 'tilmeldRemoveOldRows') {
+      const etypes = await this.getEtypes();
+
+      for (let etype of etypes) {
+        await this.removeTilmeldOldRows(etype);
+      }
+    }
+  }
 }