@nocobase/database 0.9.0-alpha.2 → 0.9.1-alpha.2

package/src/filter-parser.ts

@@ -178,7 +178,7 @@ export default class FilterParser {
           origins.push(attr);
           // if it is target model attribute
           if (target.rawAttributes[attr]) {
-            associationKeys.push(attr);
+            associationKeys.push(target.rawAttributes[attr].field || attr);
             target = null;
           } else if (target.associations[attr]) {
             // if it is target model association (nested association filter)

package/src/index.ts

@@ -1,9 +1,12 @@
 export { DataTypes, ModelStatic, Op, SyncOptions } from 'sequelize';
 export * from './collection';
-export * from './inherited-collection';
+export * from './collection-importer';
 export * from './database';
 export { Database as default } from './database';
+export * from './field-repository/array-field-repository';
 export * from './fields';
+export * from './filter-match';
+export * from './inherited-collection';
 export * from './magic-attribute-model';
 export * from './migration';
 export * from './mock-database';
@@ -15,6 +18,6 @@ export * from './relation-repository/multiple-relation-repository';
 export * from './relation-repository/single-relation-repository';
 export * from './repository';
 export * from './update-associations';
-export * from './collection-importer';
-export * from './filter-match';
-export * from './field-repository/array-field-repository';
+export { snakeCase } from './utils';
+export * from './value-parsers';
+

package/src/inherited-collection.ts

@@ -4,6 +4,7 @@ import { Field } from '.';
 
 export class InheritedCollection extends Collection {
   parents?: Collection[];
+
   constructor(options: CollectionOptions, context: CollectionContext) {
     if (!options.inherits) {
       throw new Error('InheritedCollection must have inherits option');

package/src/mock-database.ts

@@ -31,10 +31,12 @@ export function getConfigByEnv() {
       collate: 'utf8mb4_unicode_ci',
     },
     timezone: process.env.DB_TIMEZONE,
+    underscored: process.env.DB_UNDERSCORED === 'true',
+    schema: process.env.DB_SCHEMA !== 'public' ? process.env.DB_SCHEMA : undefined,
   };
 }
 
 export function mockDatabase(options: IDatabaseOptions = {}): MockDatabase {
-  const dbOptions = merge(getConfigByEnv(), options);
+  const dbOptions = merge(getConfigByEnv(), options) as any;
   return new MockDatabase(dbOptions);
 }

package/src/model.ts

@@ -1,9 +1,8 @@
 import lodash from 'lodash';
-import { DataTypes, Model as SequelizeModel, ModelStatic } from 'sequelize';
+import { Model as SequelizeModel, ModelStatic } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
 import { Field } from './fields';
-import type { InheritedCollection } from './inherited-collection';
 import { SyncRunner } from './sync-runner';
 
 const _ = lodash;
@@ -28,6 +27,7 @@ export class Model<TModelAttributes extends {} = any, TCreationAttributes extend
   public static collection: Collection;
 
   [key: string]: any;
+
   protected _changedWithAssociations = new Set();
   protected _previousDataValuesWithAssociations = {};
 
@@ -153,6 +153,15 @@ export class Model<TModelAttributes extends {} = any, TCreationAttributes extend
   static async sync(options) {
     const model = this as any;
 
+    const _schema = model._schema;
+
+    if (_schema && _schema != 'public') {
+      await this.sequelize.query(`CREATE SCHEMA IF NOT EXISTS "${_schema}";`, {
+        raw: true,
+        transaction: options?.transaction,
+      });
+    }
+
     // fix sequelize sync with model that not have any column
     if (Object.keys(model.tableAttributes).length === 0) {
       if (this.database.inDialect('sqlite', 'mysql')) {

package/src/options-parser.ts

@@ -75,6 +75,7 @@ export class OptionsParser {
     for (const sortKey of sort) {
       let direction = sortKey.startsWith('-') ? 'DESC' : 'ASC';
       let sortField: Array<any> = sortKey.replace('-', '').split('.');
+
       if (this.database.inDialect('postgres', 'sqlite')) {
         direction = `${direction} NULLS LAST`;
       }
@@ -86,7 +87,11 @@ export class OptionsParser {
           sortField[i] = associationModel.associations[associationKey].target;
           associationModel = sortField[i];
         }
+      } else {
+        const rawField = this.model.rawAttributes[sortField[0]];
+        sortField[0] = rawField?.field || sortField[0];
       }
+
       sortField.push(direction);
       if (this.database.inDialect('mysql')) {
         orderParams.push([Sequelize.fn('ISNULL', Sequelize.col(`${this.model.name}.${sortField[0]}`))]);

package/src/query-interface/mysql-query-interface.ts

@@ -0,0 +1,20 @@
+import QueryInterface from './query-interface';
+import { Collection } from '../collection';
+import { Transactionable } from 'sequelize';
+
+export default class MysqlQueryInterface extends QueryInterface {
+  constructor(db) {
+    super(db);
+  }
+
+  async collectionTableExists(collection: Collection, options?: Transactionable) {
+    const transaction = options?.transaction;
+
+    const tableName = collection.model.tableName;
+    const databaseName = this.db.options.database;
+    const sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '${databaseName}' AND TABLE_NAME = '${tableName}'`;
+
+    const results = await this.db.sequelize.query(sql, { type: 'SELECT', transaction });
+    return results.length > 0;
+  }
+}

package/src/query-interface/postgres-query-interface.ts

@@ -0,0 +1,22 @@
+import QueryInterface from './query-interface';
+import { Collection } from '../collection';
+
+export default class PostgresQueryInterface extends QueryInterface {
+  constructor(db) {
+    super(db);
+  }
+
+  async collectionTableExists(collection: Collection, options?) {
+    const transaction = options?.transaction;
+
+    const tableName = collection.model.tableName;
+    const schema = collection.collectionSchema() || 'public';
+
+    const sql = `SELECT EXISTS(SELECT 1 FROM information_schema.tables
+                 WHERE  table_schema = '${schema}'
+                 AND    table_name   = '${tableName}')`;
+
+    const results = await this.db.sequelize.query(sql, { type: 'SELECT', transaction });
+    return results[0]['exists'];
+  }
+}

package/src/query-interface/query-interface-builder.ts

@@ -0,0 +1,14 @@
+import Database from '../database';
+import MysqlQueryInterface from './mysql-query-interface';
+import PostgresQueryInterface from './postgres-query-interface';
+import SqliteQueryInterface from './sqlite-query-interface';
+
+export default function buildQueryInterface(db: Database) {
+  const map = {
+    mysql: MysqlQueryInterface,
+    postgres: PostgresQueryInterface,
+    sqlite: SqliteQueryInterface,
+  };
+
+  return new map[db.options.dialect](db);
+}

package/src/query-interface/query-interface.ts

@@ -0,0 +1,12 @@
+import Database from '../database';
+import { Collection } from '../collection';
+import { QueryInterface as SequelizeQueryInterface, Transactionable } from 'sequelize';
+
+export default abstract class QueryInterface {
+  sequelizeQueryInterface: SequelizeQueryInterface;
+  protected constructor(public db: Database) {
+    this.sequelizeQueryInterface = db.sequelize.getQueryInterface();
+  }
+
+  abstract collectionTableExists(collection: Collection, options?: Transactionable): Promise<boolean>;
+}

package/src/query-interface/sqlite-query-interface.ts

@@ -0,0 +1,18 @@
+import QueryInterface from './query-interface';
+import { Collection } from '../collection';
+
+export default class SqliteQueryInterface extends QueryInterface {
+  constructor(db) {
+    super(db);
+  }
+
+  async collectionTableExists(collection: Collection, options?) {
+    const transaction = options?.transaction;
+
+    const tableName = collection.model.tableName;
+
+    const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName}';`;
+    const results = await this.db.sequelize.query(sql, { type: 'SELECT', transaction });
+    return results.length > 0;
+  }
+}

package/src/relation-repository/belongs-to-many-repository.ts

@@ -62,6 +62,8 @@ export class BelongsToManyRepository extends MultipleRelationRepository implemen
     const transaction = await this.getTransaction(options);
     const association = <BelongsToMany>this.association;
 
+    const throughModel = this.throughModel();
+
     const instancesToIds = (instances) => {
       return instances.map((instance) => instance.get(this.targetKey()));
     };
@@ -69,7 +71,7 @@ export class BelongsToManyRepository extends MultipleRelationRepository implemen
     // Through Table
     const throughTableWhere: Array<any> = [
       {
-        [association.foreignKey]: this.sourceKeyValue,
+        [throughModel.rawAttributes[association.foreignKey].field]: this.sourceKeyValue,
       },
     ];
 
@@ -100,7 +102,7 @@ export class BelongsToManyRepository extends MultipleRelationRepository implemen
     }
 
     throughTableWhere.push({
-      [association.otherKey]: {
+      [throughModel.rawAttributes[association.otherKey].field]: {
         [Op.in]: ids,
       },
     });

package/src/relation-repository/multiple-relation-repository.ts

@@ -42,6 +42,8 @@ export abstract class MultipleRelationRepository extends RelationRepository {
     const getAccessor = this.accessors().get;
     const sourceModel = await this.getSourceModel(transaction);
 
+    if (!sourceModel) return [];
+
     if (findOptions.include && findOptions.include.length > 0) {
       const ids = (
         await sourceModel[getAccessor]({
@@ -103,6 +105,8 @@ export abstract class MultipleRelationRepository extends RelationRepository {
     const transaction = await this.getTransaction(options);
 
     const sourceModel = await this.getSourceModel(transaction);
+    if (!sourceModel) return 0;
+
     const queryOptions = this.buildQueryOptions(options);
 
     const count = await sourceModel[this.accessors().get]({

package/src/relation-repository/single-relation-repository.ts

@@ -54,6 +54,8 @@ export abstract class SingleRelationRepository extends RelationRepository {
     const getAccessor = this.accessors().get;
     const sourceModel = await this.getSourceModel(transaction);
 
+    if (!sourceModel) return null;
+
     if (findOptions?.include?.length > 0) {
       const templateModel = await sourceModel[getAccessor]({
         ...findOptions,

package/src/repository.ts

@@ -11,7 +11,7 @@ import {
   Op,
   Transactionable,
   UpdateOptions as SequelizeUpdateOptions,
-  WhereOperators
+  WhereOperators,
 } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
@@ -407,7 +407,12 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
 
     const transaction = await this.getTransaction(options);
 
-    const guard = UpdateGuard.fromOptions(this.model, { ...options, action: 'create' });
+    const guard = UpdateGuard.fromOptions(this.model, {
+      ...options,
+      action: 'create',
+      underscored: this.collection.options.underscored,
+    });
+
     const values = guard.sanitize(options.values || {});
 
     const instance = await this.model.create<any>(values, {
@@ -476,7 +481,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     }
     const transaction = await this.getTransaction(options);
 
-    const guard = UpdateGuard.fromOptions(this.model, options);
+    const guard = UpdateGuard.fromOptions(this.model, { ...options, underscored: this.collection.options.underscored });
 
     const values = guard.sanitize(options.values);
 

package/src/sync-runner.ts

@@ -1,6 +1,5 @@
 import { InheritedCollection } from './inherited-collection';
 import lodash from 'lodash';
-import { Sequelize } from 'sequelize';
 
 export class SyncRunner {
   static async syncInheritModel(model: any, options: any) {
@@ -8,6 +7,7 @@ export class SyncRunner {
 
     const inheritedCollection = model.collection as InheritedCollection;
     const db = inheritedCollection.context.database;
+
     const dialect = db.sequelize.getDialect();
 
     const queryInterface = db.sequelize.getQueryInterface();
@@ -26,9 +26,7 @@ export class SyncRunner {
       );
     }
 
-    const parentTables = parents.map((parent) => parent.model.tableName);
-
-    const tableName = model.getTableName();
+    const tableName = inheritedCollection.addSchemaTableName();
 
     const attributes = model.tableAttributes;
 
@@ -39,11 +37,15 @@ export class SyncRunner {
     let maxSequenceVal = 0;
     let maxSequenceName;
 
+    // find max sequence
     if (childAttributes.id && childAttributes.id.autoIncrement) {
-      for (const parent of parentTables) {
+      for (const parent of parents) {
         const sequenceNameResult = await queryInterface.sequelize.query(
-          `SELECT column_default FROM information_schema.columns WHERE 
-          table_name='${parent}' and "column_name" = 'id';`,
+          `SELECT column_default
+           FROM information_schema.columns
+           WHERE table_name = '${parent.model.tableName}'
+            and table_schema = '${parent.collectionSchema()}'
+             and "column_name" = 'id';`,
           {
             transaction,
           },
@@ -59,13 +61,14 @@ export class SyncRunner {
           throw new Error(`Can't find sequence name of ${parent}`);
         }
 
-        const regex = new RegExp(/nextval\('("?\w+"?)\'.*\)/);
+        const regex = new RegExp(/nextval\('(.*)'::regclass\)/);
         const match = regex.exec(columnDefault);
 
         const sequenceName = match[1];
 
         const sequenceCurrentValResult = await queryInterface.sequelize.query(
-          `select last_value from ${sequenceName}`,
+          `select last_value
+           from ${sequenceName}`,
           {
             transaction,
           },
@@ -80,26 +83,27 @@ export class SyncRunner {
       }
     }
 
-    await this.createTable(tableName, childAttributes, options, model, parentTables);
+    await this.createTable(tableName, childAttributes, options, model, parents);
 
+    // if we have max sequence, set it to child table
     if (maxSequenceName) {
-      const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map(
-        (parent) => db.getCollection(parent).model.tableName,
+      const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map((parent) =>
+        db.getCollection(parent).addSchemaTableName(),
       );
 
       const sequenceTables = [...parentsDeep, tableName];
 
       for (const sequenceTable of sequenceTables) {
-        const queryName = Boolean(sequenceTable.match(/[A-Z]/)) ? `"${sequenceTable}"` : sequenceTable;
+        const tableName = sequenceTable.tableName;
+        const schemaName = sequenceTable.schema;
+
+        const queryName = Boolean(tableName.match(/[A-Z]/)) && !tableName.includes(`"`) ? `"${tableName}"` : tableName;
 
         const idColumnQuery = await queryInterface.sequelize.query(
-          `
-SELECT true
-FROM   pg_attribute 
-WHERE  attrelid = '${queryName}'::regclass  -- cast to a registered class (table)
-AND    attname = 'id'
-AND    NOT attisdropped 
-`,
+          `SELECT column_name
+FROM information_schema.columns
+WHERE table_name='${queryName}' and column_name='id' and table_schema = '${schemaName}';
+          `,
           {
             transaction,
           },
@@ -110,7 +114,8 @@ AND    NOT attisdropped
         }
 
         await queryInterface.sequelize.query(
-          `alter table "${sequenceTable}" alter column id set default nextval('${maxSequenceName}')`,
+          `alter table ${db.utils.quoteTable(sequenceTable)}
+            alter column id set default nextval('${maxSequenceName}')`,
           {
             transaction,
           },
@@ -121,7 +126,9 @@ AND    NOT attisdropped
     if (options.alter) {
       const columns = await queryInterface.describeTable(tableName, options);
 
-      for (const columnName in childAttributes) {
+      for (const attribute in childAttributes) {
+        const columnName = childAttributes[attribute].field;
+
         if (!columns[columnName]) {
           await queryInterface.addColumn(tableName, columnName, childAttributes[columnName], options);
         }
@@ -129,7 +136,7 @@ AND    NOT attisdropped
     }
   }
 
-  static async createTable(tableName, attributes, options, model, parentTables) {
+  static async createTable(tableName, attributes, options, model, parents) {
     let sql = '';
 
     options = { ...options };
@@ -154,7 +161,11 @@ AND    NOT attisdropped
 
     sql = `${queryGenerator.createTableQuery(tableName, attributes, options)}`.replace(
       ';',
-      ` INHERITS (${parentTables.map((t) => `"${t}"`).join(', ')});`,
+      ` INHERITS (${parents
+        .map((t) => {
+          return t.addSchemaTableName();
+        })
+        .join(', ')});`,
     );
 
     return await model.sequelize.query(sql, options);

package/src/types.ts

@@ -16,6 +16,10 @@ export type ModelCreateWithAssociationsEventType = 'afterCreateWithAssociations'
 export type ModelUpdateWithAssociationsEventType = 'afterUpdateWithAssociations';
 export type ModelSaveWithAssociationsEventType = 'afterSaveWithAssociations';
 
+export type ModelBulkCreateEvnetType = 'beforeBulkCreate' | 'afterBulkCreate';
+export type ModelBulkUpdateEvnetType = 'beforeBulkUpdate' | 'afterBulkUpdate';
+export type ModelBulkDestroyEvnetType = 'beforeBulkDestroy' | 'afterBulkDestroy';
+
 export type ModelValidateEventTypes = ModelValidateEventType | `${CollectionNameType}.${ModelValidateEventType}`;
 export type ModelCreateEventTypes = ModelCreateEventType | `${CollectionNameType}.${ModelCreateEventType}`;
 export type ModelUpdateEventTypes = ModelUpdateEventType | `${CollectionNameType}.${ModelUpdateEventType}`;
@@ -25,6 +29,10 @@ export type ModelCreateWithAssociationsEventTypes = ModelCreateWithAssociationsE
 export type ModelUpdateWithAssociationsEventTypes = ModelUpdateWithAssociationsEventType | `${CollectionNameType}.${ModelUpdateWithAssociationsEventType}`;
 export type ModelSaveWithAssociationsEventTypes = ModelSaveWithAssociationsEventType | `${CollectionNameType}.${ModelSaveWithAssociationsEventType}`;
 
+export type ModelBulkCreateEvnetTypes = ModelBulkCreateEvnetType | `${CollectionNameType}.${ModelBulkCreateEvnetType}`;
+export type ModelBulkUpdateEvnetTypes = ModelBulkUpdateEvnetType | `${CollectionNameType}.${ModelBulkUpdateEvnetType}`;
+export type ModelBulkDestroyEvnetTypes = ModelBulkDestroyEvnetType | `${CollectionNameType}.${ModelBulkDestroyEvnetType}`;
+
 export type ModelEventTypes = ModelSyncEventType
   | ModelValidateEventTypes
   | ModelCreateEventTypes
@@ -33,7 +41,10 @@ export type ModelEventTypes = ModelSyncEventType
   | ModelDestroyEventTypes
   | ModelCreateWithAssociationsEventTypes
   | ModelUpdateWithAssociationsEventTypes
-  | ModelSaveWithAssociationsEventTypes;
+  | ModelSaveWithAssociationsEventTypes
+  | ModelBulkCreateEvnetTypes
+  | ModelBulkUpdateEvnetTypes
+  | ModelBulkDestroyEvnetTypes;
 
 export type DatabaseBeforeDefineCollectionEventType = 'beforeDefineCollection';
 export type DatabaseAfterDefineCollectionEventType = 'afterDefineCollection';

package/src/update-associations.ts

@@ -6,7 +6,7 @@ import {
   HasOne,
   Hookable,
   ModelStatic,
-  Transactionable,
+  Transactionable
 } from 'sequelize';
 import { Model } from './model';
 import { UpdateGuard } from './update-guard';
@@ -392,7 +392,7 @@ export async function updateMultipleAssociation(
     }
 
     if (isStringOrNumber(value)) {
-      await model[setAccessor](value, { transaction, context });
+      await model[setAccessor](value, { transaction, context, individualHooks: true });
       return;
     }
 
@@ -402,6 +402,7 @@ export async function updateMultipleAssociation(
 
     const list1 = []; // to be setted
     const list2 = []; // to be added
+    const created = [];
     for (const item of value) {
       if (isUndefinedOrNull(item)) {
         continue;
@@ -413,12 +414,17 @@ export async function updateMultipleAssociation(
       } else if (item.sequelize) {
         list1.push(item);
       } else if (typeof item === 'object') {
+        const targetKey = (association as any).targetKey || 'id';
+        if (item[targetKey]) {
+          created.push(item[targetKey]);
+          list1.push(item[targetKey]);
+        }
         list2.push(item);
       }
     }
 
     // associate targets in lists1
-    await model[setAccessor](list1, { transaction, context });
+    await model[setAccessor](list1, { transaction, context, individualHooks: true });
 
     const list3 = [];
     for (const item of list2) {
@@ -456,8 +462,9 @@ export async function updateMultipleAssociation(
           continue;
         }
         const addAccessor = association.accessors.add;
-
-        await model[addAccessor](item[pk], accessorOptions);
+        if (!created.includes(item[pk])) {
+          await model[addAccessor](item[pk], accessorOptions);
+        }
         if (!recursive) {
           continue;
         }

package/src/update-guard.ts

@@ -13,6 +13,7 @@ type UpdateAction = 'create' | 'update';
 export class UpdateGuard {
   model: ModelStatic<any>;
   action: UpdateAction;
+  underscored: boolean;
   private associationKeysToBeUpdate: AssociationKeysToBeUpdate;
   private blackList: BlackList;
   private whiteList: WhiteList;
@@ -162,6 +163,11 @@ export class UpdateGuard {
     guard.setBlackList(options.blacklist);
     guard.setAction(lodash.get(options, 'action', 'update'));
     guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
+
+    if (options.underscored) {
+      guard.underscored = options.underscored;
+    }
+
     return guard;
   }
 }

package/src/utils.ts

@@ -1,6 +1,8 @@
 import crypto from 'crypto';
+import Database from './database';
 import { IdentifierError } from './errors/identifier-error';
 import { Model } from './model';
+import lodash from 'lodash';
 
 type HandleAppendsQueryOptions = {
   templateModel: any;
@@ -73,3 +75,96 @@ export function checkIdentifier(value: string) {
     throw new IdentifierError(`Identifier ${value} is too long`);
   }
 }
+
+export function getTableName(collectionName: string, options) {
+  return options.underscored ? snakeCase(collectionName) : collectionName;
+}
+
+export function snakeCase(name: string) {
+  return require('sequelize').Utils.underscore(name);
+}
+
+function patchShowConstraintsQuery(queryGenerator, db) {
+  queryGenerator.showConstraintsQuery = (tableName, constraintName) => {
+    const lines = [
+      'SELECT constraint_catalog AS "constraintCatalog",',
+      'constraint_schema AS "constraintSchema",',
+      'constraint_name AS "constraintName",',
+      'table_catalog AS "tableCatalog",',
+      'table_schema AS "tableSchema",',
+      'table_name AS "tableName",',
+      'constraint_type AS "constraintType",',
+      'is_deferrable AS "isDeferrable",',
+      'initially_deferred AS "initiallyDeferred"',
+      'from INFORMATION_SCHEMA.table_constraints',
+      `WHERE table_name='${lodash.isPlainObject(tableName) ? tableName.tableName : tableName}'`,
+    ];
+
+    if (!constraintName) {
+      lines.push(`AND constraint_name='${constraintName}'`);
+    }
+
+    if (lodash.isPlainObject(tableName) && tableName.schema) {
+      lines.push(`AND table_schema='${tableName.schema}'`);
+    }
+
+    return lines.join(' ');
+  };
+}
+
+function patchDescribeTableQuery(queryGenerator) {
+  const describeTableQuery = function (tableName, schema) {
+    schema = schema || this.options.schema || 'public';
+
+    return (
+      'SELECT ' +
+      'pk.constraint_type as "Constraint",' +
+      'c.column_name as "Field", ' +
+      'c.column_default as "Default",' +
+      'c.is_nullable as "Null", ' +
+      "(CASE WHEN c.udt_name = 'hstore' THEN c.udt_name ELSE c.data_type END) || (CASE WHEN c.character_maximum_length IS NOT NULL THEN '(' || c.character_maximum_length || ')' ELSE '' END) as \"Type\", " +
+      '(SELECT array_agg(e.enumlabel) FROM pg_catalog.pg_type t JOIN pg_catalog.pg_enum e ON t.oid=e.enumtypid WHERE t.typname=c.udt_name) AS "special", ' +
+      '(SELECT pgd.description FROM pg_catalog.pg_statio_all_tables AS st INNER JOIN pg_catalog.pg_description pgd on (pgd.objoid=st.relid) WHERE c.ordinal_position=pgd.objsubid AND c.table_name=st.relname AND st.schemaname = c.table_schema) AS "Comment" ' +
+      'FROM information_schema.columns c ' +
+      'LEFT JOIN (SELECT tc.table_schema, tc.table_name, ' +
+      'cu.column_name, tc.constraint_type ' +
+      'FROM information_schema.TABLE_CONSTRAINTS tc ' +
+      'JOIN information_schema.KEY_COLUMN_USAGE  cu ' +
+      'ON tc.table_schema=cu.table_schema and tc.table_name=cu.table_name ' +
+      'and tc.constraint_name=cu.constraint_name ' +
+      "and tc.constraint_type='PRIMARY KEY') pk " +
+      'ON pk.table_schema=c.table_schema ' +
+      'AND pk.table_name=c.table_name ' +
+      'AND pk.column_name=c.column_name ' +
+      `WHERE c.table_name = ${this.escape(tableName)} AND c.table_schema = ${this.escape(schema)}`
+    );
+  };
+
+  queryGenerator.describeTableQuery = describeTableQuery.bind(queryGenerator);
+}
+
+export function patchSequelizeQueryInterface(db: Database) {
+  if (db.inDialect('postgres')) {
+    //@ts-ignore
+    const queryGenerator = db.sequelize.dialect.queryGenerator;
+    patchShowConstraintsQuery(queryGenerator, db);
+    patchDescribeTableQuery(queryGenerator);
+  }
+}
+
+export function percent2float(value: string) {
+  if (!value.endsWith('%')) {
+    return NaN;
+  }
+  let val = value.substring(0, value.length - 1);
+  if (isNaN(+val)) {
+    return NaN;
+  }
+  const index = value.indexOf('.');
+  if (index === -1) {
+    return parseFloat(value) / 100;
+  }
+  const repeat = value.length - index - 2;
+  const v = parseInt('1' + '0'.repeat(repeat));
+  return (parseFloat(value) * v) / (100 * v);
+}