sedentary-pg 0.0.22 → 0.0.25

package/index.d.ts

@@ -1,9 +1,12 @@
 import { EntryBase, ForeignKeyOptions, Natural, Sedentary, SedentaryOptions, Type } from "sedentary";
-import { Attribute } from "sedentary/lib/db";
+import { Attribute } from "sedentary/db";
 import { PoolConfig } from "pg";
+import { PGDB, TransactionPG } from "./pgdb";
 export { EntryBase, SedentaryOptions, Type } from "sedentary";
-export declare class SedentaryPG extends Sedentary {
+export { TransactionPG } from "./pgdb";
+export declare class SedentaryPG extends Sedentary<PGDB, TransactionPG> {
     constructor(connection: PoolConfig, options?: SedentaryOptions);
     FKEY<N extends Natural, E extends EntryBase>(attribute: Attribute<N, E>, options?: ForeignKeyOptions): Type<N, E>;
+    begin(): Promise<TransactionPG>;
 }
 export declare const Package: typeof SedentaryPG;

package/index.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Package = exports.SedentaryPG = exports.Type = exports.EntryBase = void 0;
+exports.Package = exports.SedentaryPG = exports.TransactionPG = exports.Type = exports.EntryBase = void 0;
 const sedentary_1 = require("sedentary");
-const pgdb_1 = require("./lib/pgdb");
+const pgdb_1 = require("./pgdb");
 var sedentary_2 = require("sedentary");
 Object.defineProperty(exports, "EntryBase", { enumerable: true, get: function () { return sedentary_2.EntryBase; } });
 Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return sedentary_2.Type; } });
+var pgdb_2 = require("./pgdb");
+Object.defineProperty(exports, "TransactionPG", { enumerable: true, get: function () { return pgdb_2.TransactionPG; } });
 class SedentaryPG extends sedentary_1.Sedentary {
     constructor(connection, options) {
-        super("", options);
+        super(options);
         if (!(connection instanceof Object))
             throw new Error("SedentaryPG.constructor: 'connection' argument: Wrong type, expected 'Object'");
         this.db = new pgdb_1.PGDB(connection, this.log);
@@ -19,6 +21,9 @@ class SedentaryPG extends sedentary_1.Sedentary {
             throw new Error(`Sedentary.FKEY: '${modelName}' model: '${attributeName}' attribute: is not unique: can't be used as FKEY target`);
         return super.FKEY(attribute, options);
     }
+    async begin() {
+        return this.db.begin();
+    }
 }
 exports.SedentaryPG = SedentaryPG;
 exports.Package = SedentaryPG;

package/package.json

@@ -6,26 +6,25 @@
     "yossarian <sergiybiluk@gmail.com> (https://github.com/captain-yossarian)"
   ],
   "dependencies": {
-    "pg": "8.7.1",
+    "@types/pg": "8.6.4",
+    "pg": "8.7.3",
     "pg-format": "1.0.4",
-    "sedentary": "0.0.22"
+    "sedentary": "0.0.25"
   },
   "description": "The ORM which never needs to migrate - PostgreSQL",
   "devDependencies": {
-    "@types/mocha": "9.0.0",
-    "@types/node": "17.0.5",
-    "@types/pg": "8.6.3",
+    "@types/mocha": "9.1.0",
+    "@types/node": "17.0.19",
     "@types/pg-format": "1.0.2",
     "@types/yamljs": "0.2.31",
-    "@typescript-eslint/eslint-plugin": "5.8.1",
-    "@typescript-eslint/parser": "5.8.1",
-    "eslint": "8.5.0",
-    "mocha": "9.1.3",
+    "@typescript-eslint/eslint-plugin": "5.12.1",
+    "@typescript-eslint/parser": "5.12.1",
+    "eslint": "8.9.0",
+    "mocha": "9.2.1",
     "nyc": "15.1.0",
     "prettier": "2.5.1",
-    "ts-node": "10.4.0",
-    "tsd": "0.19.0",
-    "typescript": "4.5.4",
+    "ts-node": "10.5.0",
+    "typescript": "4.5.5",
     "yamljs": "0.3.0"
   },
   "engines": {
@@ -84,5 +83,5 @@
     }
   },
   "types": "index.d.ts",
-  "version": "0.0.22"
+  "version": "0.0.25"
 }

package/pgdb.d.ts

@@ -0,0 +1,40 @@
+import { PoolClient, PoolConfig } from "pg";
+import { Attribute, DB, EntryBase, Natural, Table, Transaction } from "sedentary/db";
+export declare class PGDB extends DB<TransactionPG> {
+    private client;
+    private indexes;
+    private oidLoad;
+    private pool;
+    private version;
+    constructor(connection: PoolConfig, log: (message: string) => void);
+    connect(): Promise<void>;
+    end(): Promise<void>;
+    defaultNeq(src: string, value: Natural): boolean;
+    begin(): Promise<TransactionPG>;
+    escape(value: Natural): string;
+    fill(attributes: Record<string, string>, row: Record<string, Natural>, entry: Record<string, Natural>): void;
+    load(tableName: string, attributes: Record<string, string>, pk: Attribute<Natural, unknown>, model: new (from: "load") => EntryBase, table: Table): (where: string, order?: string[], tx?: Transaction) => Promise<EntryBase[]>;
+    save(tableName: string, attributes: Record<string, string>, pk: Attribute<Natural, unknown>): (this: Record<string, Natural> & {
+        loaded?: Record<string, unknown>;
+        tx?: TransactionPG;
+    }) => Promise<boolean>;
+    dropConstraints(table: Table): Promise<number[]>;
+    dropField(tableName: string, fieldName: string): Promise<void>;
+    dropFields(table: Table): Promise<void>;
+    dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
+    syncConstraints(table: Table): Promise<void>;
+    syncDataBase(): Promise<void>;
+    fieldType(attribute: Attribute<Natural, unknown>): string[];
+    syncFields(table: Table): Promise<void>;
+    syncIndexes(table: Table): Promise<void>;
+    syncSequence(table: Table): Promise<void>;
+    syncTable(table: Table): Promise<void>;
+}
+export declare class TransactionPG extends Transaction {
+    client: PoolClient;
+    released: boolean;
+    constructor(client: PoolClient);
+    private release;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}

package/{lib/pgdb.js → pgdb.js}

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PGDB = void 0;
+exports.TransactionPG = exports.PGDB = void 0;
 const pg_1 = require("pg");
 const pg_format_1 = __importDefault(require("pg-format"));
-const db_1 = require("sedentary/lib/db");
+const db_1 = require("sedentary/db");
 const adsrc_1 = require("./adsrc");
 const needDrop = [
     ["DATETIME", "int2"],
@@ -20,11 +20,12 @@ const needUsing = [
     ["INT", "varchar"],
     ["INT8", "varchar"]
 ];
-const types = { int2: "SMALLINT", int4: "INTEGER", int8: "BIGINT", varchar: "VARCHAR" };
+const types = { int2: "SMALLINT", int4: "INTEGER", int8: "BIGINT", timestamptz: "DATETIME", varchar: "VARCHAR" };
 const actions = { cascade: "c", "no action": "a", restrict: "r", "set default": "d", "set null": "n" };
 class PGDB extends db_1.DB {
     constructor(connection, log) {
         super(log);
+        this.oidLoad = {};
         this.client = {};
         this.indexes = [];
         this.pool = new pg_1.Pool(connection);
@@ -35,6 +36,125 @@ class PGDB extends db_1.DB {
         const res = await this.client.query("SELECT version()");
         this.version = parseInt(res.rows[0].version.split(" ")[1].split(".")[0], 10);
     }
+    async end() {
+        if (this.client.release)
+            this.client.release();
+        await this.pool.end();
+    }
+    defaultNeq(src, value) {
+        if (src === value)
+            return false;
+        return src.split("::")[0] !== value;
+    }
+    async begin() {
+        const ret = new TransactionPG(await this.pool.connect());
+        await ret.client.query("BEGIN");
+        return ret;
+    }
+    escape(value) {
+        if (value === null || value === undefined)
+            throw new Error("SedentaryPG: Can't escape null nor undefined values; use the 'IS NULL' operator instead");
+        const type = typeof value;
+        if (type === "number" || type === "boolean")
+            return value.toString();
+        if (type === "string")
+            return (0, pg_format_1.default)("%L", value);
+        if (value instanceof Date)
+            return (0, pg_format_1.default)("%L", value).replace(/\.\d\d\d\+/, "+");
+        return (0, pg_format_1.default)("%L", JSON.stringify(value));
+    }
+    fill(attributes, row, entry) {
+        const loaded = {};
+        for (const attribute in attributes)
+            entry[attribute] = loaded[attribute] = row[attributes[attribute]];
+        Object.defineProperty(entry, "loaded", { configurable: true, value: loaded });
+    }
+    load(tableName, attributes, pk, model, table) {
+        const pkFldName = pk.fieldName;
+        return async (where, order, tx) => {
+            const { oid } = table;
+            const ret = [];
+            const client = tx ? tx.client : await this.pool.connect();
+            const oidPK = {};
+            try {
+                const query = `SELECT *, tableoid FROM ${tableName}${where ? ` WHERE ${where}` : ""}${order && order.length ? ` ORDER BY ${order.map(_ => (_.startsWith("-") ? `${_.substring(1)} DESC` : _)).join(",")}` : ""}`;
+                this.log(query);
+                const res = await client.query(query);
+                for (const row of res.rows) {
+                    if (row.tableoid === oid) {
+                        const entry = new model("load");
+                        this.fill(attributes, row, entry);
+                        ret.push(entry);
+                        entry.postLoad();
+                    }
+                    else {
+                        if (!oidPK[row.tableoid])
+                            oidPK[row.tableoid] = [];
+                        oidPK[row.tableoid].push([ret.length, row[pkFldName]]);
+                        ret.push(null);
+                    }
+                }
+                for (const oid in oidPK) {
+                    const res = await this.oidLoad[oid](oidPK[oid].map(_ => _[1]));
+                    for (const entry of res)
+                        for (const [id] of oidPK[oid])
+                            ret[id] = entry;
+                }
+            }
+            finally {
+                if (!tx)
+                    client.release();
+            }
+            return ret;
+        };
+    }
+    save(tableName, attributes, pk) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const pkAttrnName = pk.attributeName;
+        const pkFldName = pk.fieldName;
+        return async function () {
+            let changed = false;
+            const client = this.tx ? this.tx.client : await self.pool.connect();
+            try {
+                const { loaded } = this;
+                if (loaded) {
+                    const actions = [];
+                    for (const attribute in attributes) {
+                        const value = this[attribute];
+                        if (value !== loaded[attribute])
+                            actions.push(`${attributes[attribute]} = ${self.escape(value)}`);
+                    }
+                    if (actions.length) {
+                        const query = `UPDATE ${tableName} SET ${actions.join(", ")} WHERE ${pkFldName} = ${self.escape(this[pkAttrnName])}`;
+                        self.log(query);
+                        self.fill(attributes, (await client.query(query + " RETURNING *")).rows[0], this);
+                        changed = true;
+                    }
+                }
+                else {
+                    const fields = [];
+                    const values = [];
+                    for (const attribute in attributes) {
+                        const value = this[attribute];
+                        if (value !== null && value !== undefined) {
+                            fields.push(attributes[attribute]);
+                            values.push(self.escape(value));
+                        }
+                    }
+                    const query = fields.length ? `INSERT INTO ${tableName} (${fields.join(", ")}) VALUES (${values.join(", ")})` : `INSERT INTO ${tableName} DEFAULT VALUES`;
+                    self.log(query);
+                    self.fill(attributes, (await client.query(query + " RETURNING *")).rows[0], this);
+                    changed = true;
+                }
+            }
+            finally {
+                if (!this.tx)
+                    client.release();
+            }
+            return changed;
+        };
+    }
     async dropConstraints(table) {
         const indexes = [];
         const res = await this.client.query("SELECT confdeltype, confupdtype, conindid, conname, contype FROM pg_constraint WHERE conrelid = $1 ORDER BY conname", [table.oid]);
@@ -99,37 +219,6 @@ class PGDB extends db_1.DB {
                 await this.client.query(statement);
         }
     }
-    async end() {
-        await this.pool.end();
-    }
-    fieldType(attribute) {
-        const { size, type } = attribute;
-        let ret;
-        switch (type) {
-            case "DATETIME":
-                return ["DATETIME", "TIMESTAMP (3) WITH TIME ZONE"];
-            case "INT":
-                ret = size === 2 ? "SMALLINT" : "INTEGER";
-                return [ret, ret];
-            case "INT8":
-                return ["BIGINT", "BIGINT"];
-            case "VARCHAR":
-                return ["VARCHAR", "VARCHAR" + (size ? `(${size})` : "")];
-        }
-        throw new Error(`Unknown type: '${type}', '${size}'`);
-    }
-    async syncDataBase() {
-        let err;
-        try {
-            await super.syncDataBase();
-        }
-        catch (e) {
-            err = e;
-        }
-        this.client.release();
-        if (err)
-            throw err;
-    }
     async syncConstraints(table) {
         for (const constraint of table.constraints) {
             const { attribute, constraintName, type } = constraint;
@@ -154,11 +243,32 @@ class PGDB extends db_1.DB {
             }
         }
     }
+    async syncDataBase() {
+        await super.syncDataBase();
+        for (const table of this.tables)
+            this.oidLoad[table.oid || 0] = (ids) => table.model.load({ [table.pk.attributeName]: ["IN", ids] });
+    }
+    fieldType(attribute) {
+        const { size, type } = attribute;
+        let ret;
+        switch (type) {
+            case "DATETIME":
+                return ["DATETIME", "TIMESTAMP (3) WITH TIME ZONE"];
+            case "INT":
+                ret = size === 2 ? "SMALLINT" : "INTEGER";
+                return [ret, ret];
+            case "INT8":
+                return ["BIGINT", "BIGINT"];
+            case "VARCHAR":
+                return ["VARCHAR", "VARCHAR" + (size ? `(${size})` : "")];
+        }
+        throw new Error(`Unknown type: '${type}', '${size}'`);
+    }
     async syncFields(table) {
-        const { attributes, oid, tableName } = table;
+        const { attributes, autoIncrement, oid, tableName } = table;
         for (const attribute of attributes) {
             const { fieldName, notNull, size } = attribute;
-            const defaultValue = attribute.defaultValue === undefined ? undefined : (0, pg_format_1.default)("%L", attribute.defaultValue);
+            const defaultValue = attribute.defaultValue === undefined ? (autoIncrement && fieldName === "id" ? `nextval('${tableName}_id_seq'::regclass)` : undefined) : this.escape(attribute.defaultValue);
             const [base, type] = this.fieldType(attribute);
             const where = "attrelid = $1 AND attnum > 0 AND atttypid = pg_type.oid AND attislocal = 't' AND attname = $2";
             const res = await this.client.query(`SELECT attnotnull, atttypmod, typname, ${(0, adsrc_1.adsrc)(this.version)} FROM pg_type, pg_attribute LEFT JOIN pg_attrdef ON adrelid = attrelid AND adnum = attnum WHERE ${where}`, [oid, fieldName]);
@@ -174,32 +284,32 @@ class PGDB extends db_1.DB {
                 if (this.sync)
                     await this.client.query(statement);
             };
-            const setNotNull = async (isNull) => {
-                if (isNull === notNull)
+            const setNotNull = async (isNotNull) => {
+                if (isNotNull === notNull)
                     return;
                 const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} ${notNull ? "SET" : "DROP"} NOT NULL`;
                 this.syncLog(statement);
                 if (this.sync)
                     await this.client.query(statement);
             };
-            const setDefault = async (isNull) => {
+            const setDefault = async (isNotNull, create) => {
                 if (defaultValue !== undefined) {
                     let statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} SET DEFAULT ${defaultValue}`;
                     this.syncLog(statement);
                     if (this.sync)
                         await this.client.query(statement);
-                    if (isNull) {
+                    if (!isNotNull && !create) {
                         statement = `UPDATE ${tableName} SET ${fieldName} = ${defaultValue} WHERE ${fieldName} IS NULL`;
                         this.syncLog(statement);
                         if (this.sync)
                             this.client.query(statement);
                     }
                 }
-                await setNotNull(isNull);
+                await setNotNull(isNotNull);
             };
             if (!res.rowCount) {
                 await addField();
-                await setDefault(false);
+                await setDefault(false, true);
             }
             else {
                 const { adsrc, attnotnull, atttypmod, typname } = res.rows[0];
@@ -207,7 +317,7 @@ class PGDB extends db_1.DB {
                     if (needDrop.filter(([type, name]) => attribute.type === type && typname === name).length) {
                         await this.dropField(tableName, fieldName);
                         await addField();
-                        await setDefault(false);
+                        await setDefault(false, true);
                     }
                     else {
                         if (adsrc)
@@ -217,7 +327,7 @@ class PGDB extends db_1.DB {
                         this.syncLog(statement);
                         if (this.sync)
                             await this.client.query(statement);
-                        await setDefault(attnotnull);
+                        await setDefault(attnotnull, false);
                     }
                 }
                 else if (defaultValue === undefined) {
@@ -225,8 +335,8 @@ class PGDB extends db_1.DB {
                         dropDefault();
                     await setNotNull(attnotnull);
                 }
-                else if (!adsrc || adsrc.split("::")[0] !== defaultValue)
-                    await setDefault(attnotnull);
+                else if (!adsrc || this.defaultNeq(adsrc, defaultValue))
+                    await setDefault(attnotnull, false);
             }
         }
     }
@@ -309,4 +419,34 @@ class PGDB extends db_1.DB {
     }
 }
 exports.PGDB = PGDB;
-// farray[0].defaultValue = "nextval('" + tname + "_id_seq'::regclass)";
+class TransactionPG extends db_1.Transaction {
+    constructor(client) {
+        super();
+        this.released = false;
+        this.client = client;
+    }
+    release() {
+        this.released = true;
+        this.client.release();
+    }
+    async commit() {
+        if (!this.released) {
+            await this.client.query("COMMIT");
+            this.release();
+            super.commit();
+        }
+    }
+    async rollback() {
+        try {
+            if (!this.released) {
+                super.rollback();
+                await this.client.query("ROLLBACK");
+            }
+        }
+        finally {
+            if (!this.released)
+                this.release();
+        }
+    }
+}
+exports.TransactionPG = TransactionPG;

package/lib/adsrc.ts

@@ -1,3 +0,0 @@
-export function adsrc(version: number) {
-  return version >= 12 ? "pg_get_expr(pg_attrdef.adbin, pg_attrdef.adrelid) AS adsrc" : "adsrc";
-}

package/lib/pgdb.d.ts

@@ -1,22 +0,0 @@
-import { PoolConfig } from "pg";
-import { Attribute, DB, Natural, Table } from "sedentary/lib/db";
-export declare class PGDB extends DB {
-    private client;
-    private indexes;
-    private pool;
-    private version;
-    constructor(connection: PoolConfig, log: (message: string) => void);
-    connect(): Promise<void>;
-    dropConstraints(table: Table): Promise<number[]>;
-    dropField(tableName: string, fieldName: string): Promise<void>;
-    dropFields(table: Table): Promise<void>;
-    dropIndexes(table: Table, constraintIndexes: number[]): Promise<void>;
-    end(): Promise<void>;
-    fieldType(attribute: Attribute<Natural, unknown>): string[];
-    syncDataBase(): Promise<void>;
-    syncConstraints(table: Table): Promise<void>;
-    syncFields(table: Table): Promise<void>;
-    syncIndexes(table: Table): Promise<void>;
-    syncSequence(table: Table): Promise<void>;
-    syncTable(table: Table): Promise<void>;
-}

package/lib/pgdb.ts

@@ -1,359 +0,0 @@
-import { DatabaseError, Pool, PoolClient, PoolConfig } from "pg";
-import format from "pg-format";
-import { Attribute, DB, ForeignKeyActions, Index, Natural, Table } from "sedentary/lib/db";
-import { adsrc } from "./adsrc";
-
-const needDrop = [
-  ["DATETIME", "int2"],
-  ["DATETIME", "int4"],
-  ["DATETIME", "int8"],
-  ["INT", "timestamptz"],
-  ["INT8", "timestamptz"]
-];
-const needUsing = [
-  ["DATETIME", "varchar"],
-  ["INT", "varchar"],
-  ["INT8", "varchar"]
-];
-const types = { int2: "SMALLINT", int4: "INTEGER", int8: "BIGINT", varchar: "VARCHAR" };
-
-const actions: { [k in ForeignKeyActions]: string } = { cascade: "c", "no action": "a", restrict: "r", "set default": "d", "set null": "n" };
-
-export class PGDB extends DB {
-  private client: PoolClient;
-  private indexes: string[];
-  private pool: Pool;
-  private version: number;
-
-  constructor(connection: PoolConfig, log: (message: string) => void) {
-    super(log);
-
-    this.client = {} as PoolClient;
-    this.indexes = [];
-    this.pool = new Pool(connection);
-    this.version = 0;
-  }
-
-  async connect(): Promise<void> {
-    this.client = await this.pool.connect();
-
-    const res = await this.client.query("SELECT version()");
-
-    this.version = parseInt(res.rows[0].version.split(" ")[1].split(".")[0], 10);
-  }
-
-  async dropConstraints(table: Table): Promise<number[]> {
-    const indexes: number[] = [];
-    const res = await this.client.query("SELECT confdeltype, confupdtype, conindid, conname, contype FROM pg_constraint WHERE conrelid = $1 ORDER BY conname", [table.oid]);
-
-    for(const row of res.rows) {
-      const arr = table.constraints.filter(_ => _.constraintName === row.conname && _.type === row.contype);
-      let drop = false;
-
-      if(arr.length === 0) drop = true;
-      else if(row.contype === "u") indexes.push(row.conindid);
-      else {
-        const { options } = arr[0].attribute.foreignKey as { attributeName: string; fieldName: string; options: { onDelete: ForeignKeyActions; onUpdate: ForeignKeyActions }; tableName: string };
-
-        if(actions[options.onDelete] !== row.confdeltype || actions[options.onUpdate] !== row.confupdtype) drop = true;
-      }
-
-      if(drop) {
-        const statement = `ALTER TABLE ${table.tableName} DROP CONSTRAINT ${row.conname} CASCADE`;
-
-        this.syncLog(statement);
-        if(this.sync) await this.client.query(statement);
-      }
-    }
-
-    return indexes;
-  }
-
-  async dropField(tableName: string, fieldName: string): Promise<void> {
-    const statement = `ALTER TABLE ${tableName} DROP COLUMN ${fieldName}`;
-
-    this.syncLog(statement);
-    if(this.sync) await this.client.query(statement);
-  }
-
-  async dropFields(table: Table): Promise<void> {
-    const res = await this.client.query("SELECT attname FROM pg_attribute WHERE attrelid = $1 AND attnum > 0 AND attisdropped = false AND attinhcount = 0", [table.oid]);
-
-    for(const i in res.rows) if(! table.findField(res.rows[i].attname)) await this.dropField(table.tableName, res.rows[i].attname);
-  }
-
-  async dropIndexes(table: Table, constraintIndexes: number[]): Promise<void> {
-    const { indexes, oid } = table;
-    const iobject: { [key: string]: Index } = {};
-    const res = await this.client.query(
-      "SELECT amname, attname, indexrelid, indisunique, relname FROM pg_class, pg_index, pg_attribute, pg_am WHERE indrelid = $1 AND indexrelid = pg_class.oid AND attrelid = pg_class.oid AND relam = pg_am.oid ORDER BY attnum",
-      [oid]
-    );
-
-    for(const row of res.rows) {
-      const { amname, attname, indexrelid, indisunique, relname } = row;
-
-      if(! constraintIndexes.includes(indexrelid)) {
-        if(iobject[relname]) iobject[relname].fields.push(attname);
-        else iobject[relname] = { fields: [attname], indexName: relname, type: amname, unique: indisunique };
-      }
-    }
-
-    this.indexes = [];
-    for(const index of indexes) {
-      const { indexName } = index;
-
-      if(iobject[indexName] && this.indexesEq(index, iobject[indexName])) {
-        this.indexes.push(indexName);
-        delete iobject[indexName];
-      }
-    }
-
-    for(const index of Object.keys(iobject).sort()) {
-      const statement = `DROP INDEX ${index}`;
-
-      this.syncLog(statement);
-      if(this.sync) await this.client.query(statement);
-    }
-  }
-
-  async end(): Promise<void> {
-    await this.pool.end();
-  }
-
-  fieldType(attribute: Attribute<Natural, unknown>): string[] {
-    const { size, type } = attribute;
-    let ret;
-
-    switch(type) {
-    case "DATETIME":
-      return ["DATETIME", "TIMESTAMP (3) WITH TIME ZONE"];
-    case "INT":
-      ret = size === 2 ? "SMALLINT" : "INTEGER";
-
-      return [ret, ret];
-    case "INT8":
-      return ["BIGINT", "BIGINT"];
-    case "VARCHAR":
-      return ["VARCHAR", "VARCHAR" + (size ? `(${size})` : "")];
-    }
-
-    throw new Error(`Unknown type: '${type}', '${size}'`);
-  }
-
-  async syncDataBase(): Promise<void> {
-    let err: unknown;
-
-    try {
-      await super.syncDataBase();
-    } catch(e) {
-      err = e;
-    }
-
-    this.client.release();
-
-    if(err) throw err;
-  }
-
-  async syncConstraints(table: Table): Promise<void> {
-    for(const constraint of table.constraints) {
-      const { attribute, constraintName, type } = constraint;
-      const res = await this.client.query("SELECT attname FROM pg_attribute, pg_constraint WHERE attrelid = $1 AND conrelid = $1 AND attnum = conkey[1] AND attname = $2", [
-        table.oid,
-        attribute.fieldName
-      ]);
-
-      if(! res.rowCount) {
-        let query: string;
-
-        if(type === "f") {
-          const { fieldName, options, tableName } = attribute.foreignKey as {
-            attributeName: string;
-            fieldName: string;
-            options: { onDelete: ForeignKeyActions; onUpdate: ForeignKeyActions };
-            tableName: string;
-          };
-          const onDelete = options.onDelete !== "no action" ? ` ON DELETE ${options.onDelete.toUpperCase()}` : "";
-          const onUpdate = options.onUpdate !== "no action" ? ` ON UPDATE ${options.onUpdate.toUpperCase()}` : "";
-
-          query = `FOREIGN KEY (${attribute.fieldName}) REFERENCES ${tableName}(${fieldName})${onDelete}${onUpdate}`;
-        } else query = `UNIQUE(${attribute.fieldName})`;
-
-        const statement = `ALTER TABLE ${table.tableName} ADD CONSTRAINT ${constraintName} ${query}`;
-
-        this.syncLog(statement);
-        if(this.sync) await this.client.query(statement);
-      }
-    }
-  }
-
-  async syncFields(table: Table): Promise<void> {
-    const { attributes, oid, tableName } = table;
-
-    for(const attribute of attributes) {
-      const { fieldName, notNull, size } = attribute;
-      const defaultValue = attribute.defaultValue === undefined ? undefined : format("%L", attribute.defaultValue);
-      const [base, type] = this.fieldType(attribute);
-      const where = "attrelid = $1 AND attnum > 0 AND atttypid = pg_type.oid AND attislocal = 't' AND attname = $2";
-
-      const res = await this.client.query(
-        `SELECT attnotnull, atttypmod, typname, ${adsrc(this.version)} FROM pg_type, pg_attribute LEFT JOIN pg_attrdef ON adrelid = attrelid AND adnum = attnum WHERE ${where}`,
-        [oid, fieldName]
-      );
-
-      const addField = async () => {
-        const statement = `ALTER TABLE ${tableName} ADD COLUMN ${fieldName} ${type}`;
-
-        this.syncLog(statement);
-        if(this.sync) await this.client.query(statement);
-      };
-
-      const dropDefault = async () => {
-        const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} DROP DEFAULT`;
-
-        this.syncLog(statement);
-        if(this.sync) await this.client.query(statement);
-      };
-
-      const setNotNull = async (isNull: boolean) => {
-        if(isNull === notNull) return;
-
-        const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} ${notNull ? "SET" : "DROP"} NOT NULL`;
-
-        this.syncLog(statement);
-        if(this.sync) await this.client.query(statement);
-      };
-
-      const setDefault = async (isNull: boolean) => {
-        if(defaultValue !== undefined) {
-          let statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} SET DEFAULT ${defaultValue}`;
-
-          this.syncLog(statement);
-          if(this.sync) await this.client.query(statement);
-
-          if(isNull) {
-            statement = `UPDATE ${tableName} SET ${fieldName} = ${defaultValue} WHERE ${fieldName} IS NULL`;
-
-            this.syncLog(statement);
-            if(this.sync) this.client.query(statement);
-          }
-        }
-
-        await setNotNull(isNull);
-      };
-
-      if(! res.rowCount) {
-        await addField();
-        await setDefault(false);
-      } else {
-        const { adsrc, attnotnull, atttypmod, typname } = res.rows[0];
-
-        if(types[typname as keyof typeof types] !== base || (base === "VARCHAR" && (size ? size + 4 !== atttypmod : atttypmod !== -1))) {
-          if(needDrop.filter(([type, name]) => attribute.type === type && typname === name).length) {
-            await this.dropField(tableName, fieldName);
-            await addField();
-            await setDefault(false);
-          } else {
-            if(adsrc) dropDefault();
-
-            const using = needUsing.filter(([type, name]) => attribute.type === type && typname === name).length ? " USING " + fieldName + "::" + type : "";
-            const statement = `ALTER TABLE ${tableName} ALTER COLUMN ${fieldName} TYPE ${type}${using}`;
-
-            this.syncLog(statement);
-            if(this.sync) await this.client.query(statement);
-            await setDefault(attnotnull);
-          }
-        } else if(defaultValue === undefined) {
-          if(adsrc) dropDefault();
-          await setNotNull(attnotnull);
-        } else if(! adsrc || adsrc.split("::")[0] !== defaultValue) await setDefault(attnotnull);
-      }
-    }
-  }
-
-  async syncIndexes(table: Table): Promise<void> {
-    const { indexes, tableName } = table;
-
-    for(const index of indexes) {
-      const { fields, indexName, type, unique } = index;
-
-      if(! this.indexes.includes(indexName)) {
-        const statement = `CREATE${unique ? " UNIQUE" : ""} INDEX ${indexName} ON ${tableName} USING ${type} (${fields.join(", ")})`;
-
-        this.syncLog(statement);
-        if(this.sync) await this.client.query(statement);
-      }
-    }
-  }
-
-  async syncSequence(table: Table): Promise<void> {
-    if(! table.autoIncrementOwn) return;
-
-    const statement = `ALTER SEQUENCE ${table.tableName}_id_seq OWNED BY ${table.tableName}.id`;
-
-    this.syncLog(statement);
-    if(this.sync) await this.client.query(statement);
-  }
-
-  async syncTable(table: Table): Promise<void> {
-    if(table.autoIncrement) {
-      await (async () => {
-        try {
-          await this.client.query(`SELECT currval('${table.tableName}_id_seq')`);
-        } catch(e) {
-          if(e instanceof DatabaseError && e.code === "55000") return;
-          if(e instanceof DatabaseError && e.code === "42P01") {
-            const statement = `CREATE SEQUENCE ${table.tableName}_id_seq`;
-
-            this.syncLog(statement);
-            if(this.sync) await this.client.query(statement);
-            table.autoIncrementOwn = true;
-
-            return;
-          }
-
-          throw e;
-        }
-      })();
-    }
-
-    let create = false;
-    const resTable = await this.client.query("SELECT oid FROM pg_class WHERE relname = $1", [table.tableName]);
-
-    if(resTable.rowCount) {
-      table.oid = resTable.rows[0].oid;
-
-      let drop = false;
-      const resParent = await this.client.query("SELECT inhparent FROM pg_inherits WHERE inhrelid = $1", [table.oid]);
-
-      if(resParent.rowCount) {
-        if(! table.parent) drop = true;
-        else if(this.findTable(table.parent.tableName).oid === resParent.rows[0].inhparent) return;
-
-        drop = true;
-      } else if(table.parent) drop = true;
-
-      if(drop) {
-        const statement = `DROP TABLE ${table.tableName} CASCADE`;
-
-        create = true;
-        this.syncLog(statement);
-        if(this.sync) await this.client.query(statement);
-      }
-    } else create = true;
-
-    if(create) {
-      const parent = table.parent ? ` INHERITS (${table.parent.tableName})` : "";
-      const statement = `CREATE TABLE ${table.tableName} ()${parent}`;
-
-      this.syncLog(statement);
-      if(this.sync) await this.client.query(statement);
-
-      const resTable = await this.client.query("SELECT oid FROM pg_class WHERE relname = $1", [table.tableName]);
-
-      table.oid = resTable.rows[0]?.oid;
-    }
-  }
-}
-
-// farray[0].defaultValue = "nextval('" + tname + "_id_seq'::regclass)";