knex 0.21.20 → 0.21.21

package/lib/dialects/postgres/schema/compiler.js

@@ -1,109 +1,109 @@
-// PostgreSQL Schema Compiler
-// -------
-
-const { inherits } = require('util');
-const SchemaCompiler = require('../../../schema/compiler');
-
-function SchemaCompiler_PG() {
-  SchemaCompiler.apply(this, arguments);
-}
-inherits(SchemaCompiler_PG, SchemaCompiler);
-
-// Check whether the current table
-SchemaCompiler_PG.prototype.hasTable = function (tableName) {
-  let sql = 'select * from information_schema.tables where table_name = ?';
-  const bindings = [tableName];
-
-  if (this.schema) {
-    sql += ' and table_schema = ?';
-    bindings.push(this.schema);
-  } else {
-    sql += ' and table_schema = current_schema()';
-  }
-
-  this.pushQuery({
-    sql,
-    bindings,
-    output(resp) {
-      return resp.rows.length > 0;
-    },
-  });
-};
-
-// Compile the query to determine if a column exists in a table.
-SchemaCompiler_PG.prototype.hasColumn = function (tableName, columnName) {
-  let sql =
-    'select * from information_schema.columns where table_name = ? and column_name = ?';
-  const bindings = [tableName, columnName];
-
-  if (this.schema) {
-    sql += ' and table_schema = ?';
-    bindings.push(this.schema);
-  } else {
-    sql += ' and table_schema = current_schema()';
-  }
-
-  this.pushQuery({
-    sql,
-    bindings,
-    output(resp) {
-      return resp.rows.length > 0;
-    },
-  });
-};
-
-SchemaCompiler_PG.prototype.qualifiedTableName = function (tableName) {
-  const name = this.schema ? `${this.schema}.${tableName}` : tableName;
-  return this.formatter.wrap(name);
-};
-
-// Compile a rename table command.
-SchemaCompiler_PG.prototype.renameTable = function (from, to) {
-  this.pushQuery(
-    `alter table ${this.qualifiedTableName(
-      from
-    )} rename to ${this.formatter.wrap(to)}`
-  );
-};
-
-SchemaCompiler_PG.prototype.createSchema = function (schemaName) {
-  this.pushQuery(`create schema ${this.formatter.wrap(schemaName)}`);
-};
-
-SchemaCompiler_PG.prototype.createSchemaIfNotExists = function (schemaName) {
-  this.pushQuery(
-    `create schema if not exists ${this.formatter.wrap(schemaName)}`
-  );
-};
-
-SchemaCompiler_PG.prototype.dropSchema = function (schemaName) {
-  this.pushQuery(`drop schema ${this.formatter.wrap(schemaName)}`);
-};
-
-SchemaCompiler_PG.prototype.dropSchemaIfExists = function (schemaName) {
-  this.pushQuery(`drop schema if exists ${this.formatter.wrap(schemaName)}`);
-};
-
-SchemaCompiler_PG.prototype.dropExtension = function (extensionName) {
-  this.pushQuery(`drop extension ${this.formatter.wrap(extensionName)}`);
-};
-
-SchemaCompiler_PG.prototype.dropExtensionIfExists = function (extensionName) {
-  this.pushQuery(
-    `drop extension if exists ${this.formatter.wrap(extensionName)}`
-  );
-};
-
-SchemaCompiler_PG.prototype.createExtension = function (extensionName) {
-  this.pushQuery(`create extension ${this.formatter.wrap(extensionName)}`);
-};
-
-SchemaCompiler_PG.prototype.createExtensionIfNotExists = function (
-  extensionName
-) {
-  this.pushQuery(
-    `create extension if not exists ${this.formatter.wrap(extensionName)}`
-  );
-};
-
-module.exports = SchemaCompiler_PG;
+// PostgreSQL Schema Compiler
+// -------
+
+const { inherits } = require('util');
+const SchemaCompiler = require('../../../schema/compiler');
+
+function SchemaCompiler_PG() {
+  SchemaCompiler.apply(this, arguments);
+}
+inherits(SchemaCompiler_PG, SchemaCompiler);
+
+// Check whether the current table
+SchemaCompiler_PG.prototype.hasTable = function (tableName) {
+  let sql = 'select * from information_schema.tables where table_name = ?';
+  const bindings = [tableName];
+
+  if (this.schema) {
+    sql += ' and table_schema = ?';
+    bindings.push(this.schema);
+  } else {
+    sql += ' and table_schema = current_schema()';
+  }
+
+  this.pushQuery({
+    sql,
+    bindings,
+    output(resp) {
+      return resp.rows.length > 0;
+    },
+  });
+};
+
+// Compile the query to determine if a column exists in a table.
+SchemaCompiler_PG.prototype.hasColumn = function (tableName, columnName) {
+  let sql =
+    'select * from information_schema.columns where table_name = ? and column_name = ?';
+  const bindings = [tableName, columnName];
+
+  if (this.schema) {
+    sql += ' and table_schema = ?';
+    bindings.push(this.schema);
+  } else {
+    sql += ' and table_schema = current_schema()';
+  }
+
+  this.pushQuery({
+    sql,
+    bindings,
+    output(resp) {
+      return resp.rows.length > 0;
+    },
+  });
+};
+
+SchemaCompiler_PG.prototype.qualifiedTableName = function (tableName) {
+  const name = this.schema ? `${this.schema}.${tableName}` : tableName;
+  return this.formatter.wrap(name);
+};
+
+// Compile a rename table command.
+SchemaCompiler_PG.prototype.renameTable = function (from, to) {
+  this.pushQuery(
+    `alter table ${this.qualifiedTableName(
+      from
+    )} rename to ${this.formatter.wrap(to)}`
+  );
+};
+
+SchemaCompiler_PG.prototype.createSchema = function (schemaName) {
+  this.pushQuery(`create schema ${this.formatter.wrap(schemaName)}`);
+};
+
+SchemaCompiler_PG.prototype.createSchemaIfNotExists = function (schemaName) {
+  this.pushQuery(
+    `create schema if not exists ${this.formatter.wrap(schemaName)}`
+  );
+};
+
+SchemaCompiler_PG.prototype.dropSchema = function (schemaName) {
+  this.pushQuery(`drop schema ${this.formatter.wrap(schemaName)}`);
+};
+
+SchemaCompiler_PG.prototype.dropSchemaIfExists = function (schemaName) {
+  this.pushQuery(`drop schema if exists ${this.formatter.wrap(schemaName)}`);
+};
+
+SchemaCompiler_PG.prototype.dropExtension = function (extensionName) {
+  this.pushQuery(`drop extension ${this.formatter.wrap(extensionName)}`);
+};
+
+SchemaCompiler_PG.prototype.dropExtensionIfExists = function (extensionName) {
+  this.pushQuery(
+    `drop extension if exists ${this.formatter.wrap(extensionName)}`
+  );
+};
+
+SchemaCompiler_PG.prototype.createExtension = function (extensionName) {
+  this.pushQuery(`create extension ${this.formatter.wrap(extensionName)}`);
+};
+
+SchemaCompiler_PG.prototype.createExtensionIfNotExists = function (
+  extensionName
+) {
+  this.pushQuery(
+    `create extension if not exists ${this.formatter.wrap(extensionName)}`
+  );
+};
+
+module.exports = SchemaCompiler_PG;

package/lib/dialects/postgres/schema/tablecompiler.js

@@ -1,183 +1,183 @@
-/* eslint max-len: 0 */
-
-// PostgreSQL Table Builder & Compiler
-// -------
-
-const { inherits } = require('util');
-const TableCompiler = require('../../../schema/tablecompiler');
-
-const has = require('lodash/has');
-
-function TableCompiler_PG() {
-  TableCompiler.apply(this, arguments);
-}
-inherits(TableCompiler_PG, TableCompiler);
-
-// Compile a rename column command.
-TableCompiler_PG.prototype.renameColumn = function (from, to) {
-  return this.pushQuery({
-    sql: `alter table ${this.tableName()} rename ${this.formatter.wrap(
-      from
-    )} to ${this.formatter.wrap(to)}`,
-  });
-};
-
-TableCompiler_PG.prototype.compileAdd = function (builder) {
-  const table = this.formatter.wrap(builder);
-  const columns = this.prefixArray('add column', this.getColumns(builder));
-  return this.pushQuery({
-    sql: `alter table ${table} ${columns.join(', ')}`,
-  });
-};
-
-// Adds the "create" query to the query sequence.
-TableCompiler_PG.prototype.createQuery = function (columns, ifNot) {
-  const createStatement = ifNot
-    ? 'create table if not exists '
-    : 'create table ';
-  let sql =
-    createStatement + this.tableName() + ' (' + columns.sql.join(', ') + ')';
-  if (this.single.inherits)
-    sql += ` inherits (${this.formatter.wrap(this.single.inherits)})`;
-  this.pushQuery({
-    sql,
-    bindings: columns.bindings,
-  });
-  const hasComment = has(this.single, 'comment');
-  if (hasComment) this.comment(this.single.comment);
-};
-
-TableCompiler_PG.prototype.addColumns = function (
-  columns,
-  prefix,
-  colCompilers
-) {
-  if (prefix === this.alterColumnsPrefix) {
-    // alter columns
-    for (const col of colCompilers) {
-      const quotedTableName = this.tableName();
-      const type = col.getColumnType();
-      // We'd prefer to call this.formatter.wrapAsIdentifier here instead, however the context passed to
-      // `this` instance is not that of the column, but of the table. Thus, we unfortunately have to call
-      // `wrapIdentifier` here as well (it is already called once on the initial column operation) to give
-      // our `alter` operation the correct `queryContext`. Refer to issue #2606 and PR #2612.
-      const colName = this.client.wrapIdentifier(
-        col.getColumnName(),
-        col.columnBuilder.queryContext()
-      );
-
-      this.pushQuery({
-        sql: `alter table ${quotedTableName} alter column ${colName} drop default`,
-        bindings: [],
-      });
-      this.pushQuery({
-        sql: `alter table ${quotedTableName} alter column ${colName} drop not null`,
-        bindings: [],
-      });
-      this.pushQuery({
-        sql: `alter table ${quotedTableName} alter column ${colName} type ${type} using (${colName}::${type})`,
-        bindings: [],
-      });
-
-      const defaultTo = col.modified['defaultTo'];
-      if (defaultTo) {
-        const modifier = col.defaultTo.apply(col, defaultTo);
-        this.pushQuery({
-          sql: `alter table ${quotedTableName} alter column ${colName} set ${modifier}`,
-          bindings: [],
-        });
-      }
-
-      const nullable = col.modified['nullable'];
-      if (nullable && nullable[0] === false) {
-        this.pushQuery({
-          sql: `alter table ${quotedTableName} alter column ${colName} set not null`,
-          bindings: [],
-        });
-      }
-    }
-  } else {
-    // base class implementation for normal add
-    TableCompiler.prototype.addColumns.call(this, columns, prefix);
-  }
-};
-
-// Compiles the comment on the table.
-TableCompiler_PG.prototype.comment = function (comment) {
-  this.pushQuery(
-    `comment on table ${this.tableName()} is '${this.single.comment}'`
-  );
-};
-
-// Indexes:
-// -------
-
-TableCompiler_PG.prototype.primary = function (columns, constraintName) {
-  constraintName = constraintName
-    ? this.formatter.wrap(constraintName)
-    : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
-  this.pushQuery(
-    `alter table ${this.tableName()} add constraint ${constraintName} primary key (${this.formatter.columnize(
-      columns
-    )})`
-  );
-};
-TableCompiler_PG.prototype.unique = function (columns, indexName) {
-  indexName = indexName
-    ? this.formatter.wrap(indexName)
-    : this._indexCommand('unique', this.tableNameRaw, columns);
-  this.pushQuery(
-    `alter table ${this.tableName()} add constraint ${indexName}` +
-      ' unique (' +
-      this.formatter.columnize(columns) +
-      ')'
-  );
-};
-TableCompiler_PG.prototype.index = function (columns, indexName, indexType) {
-  indexName = indexName
-    ? this.formatter.wrap(indexName)
-    : this._indexCommand('index', this.tableNameRaw, columns);
-  this.pushQuery(
-    `create index ${indexName} on ${this.tableName()}${
-      (indexType && ` using ${indexType}`) || ''
-    }` +
-      ' (' +
-      this.formatter.columnize(columns) +
-      ')'
-  );
-};
-TableCompiler_PG.prototype.dropPrimary = function (constraintName) {
-  constraintName = constraintName
-    ? this.formatter.wrap(constraintName)
-    : this.formatter.wrap(this.tableNameRaw + '_pkey');
-  this.pushQuery(
-    `alter table ${this.tableName()} drop constraint ${constraintName}`
-  );
-};
-TableCompiler_PG.prototype.dropIndex = function (columns, indexName) {
-  indexName = indexName
-    ? this.formatter.wrap(indexName)
-    : this._indexCommand('index', this.tableNameRaw, columns);
-  indexName = this.schemaNameRaw
-    ? `${this.formatter.wrap(this.schemaNameRaw)}.${indexName}`
-    : indexName;
-  this.pushQuery(`drop index ${indexName}`);
-};
-TableCompiler_PG.prototype.dropUnique = function (columns, indexName) {
-  indexName = indexName
-    ? this.formatter.wrap(indexName)
-    : this._indexCommand('unique', this.tableNameRaw, columns);
-  this.pushQuery(
-    `alter table ${this.tableName()} drop constraint ${indexName}`
-  );
-};
-TableCompiler_PG.prototype.dropForeign = function (columns, indexName) {
-  indexName = indexName
-    ? this.formatter.wrap(indexName)
-    : this._indexCommand('foreign', this.tableNameRaw, columns);
-  this.pushQuery(
-    `alter table ${this.tableName()} drop constraint ${indexName}`
-  );
-};
-
-module.exports = TableCompiler_PG;
+/* eslint max-len: 0 */
+
+// PostgreSQL Table Builder & Compiler
+// -------
+
+const { inherits } = require('util');
+const TableCompiler = require('../../../schema/tablecompiler');
+
+const has = require('lodash/has');
+
+function TableCompiler_PG() {
+  TableCompiler.apply(this, arguments);
+}
+inherits(TableCompiler_PG, TableCompiler);
+
+// Compile a rename column command.
+TableCompiler_PG.prototype.renameColumn = function (from, to) {
+  return this.pushQuery({
+    sql: `alter table ${this.tableName()} rename ${this.formatter.wrap(
+      from
+    )} to ${this.formatter.wrap(to)}`,
+  });
+};
+
+TableCompiler_PG.prototype.compileAdd = function (builder) {
+  const table = this.formatter.wrap(builder);
+  const columns = this.prefixArray('add column', this.getColumns(builder));
+  return this.pushQuery({
+    sql: `alter table ${table} ${columns.join(', ')}`,
+  });
+};
+
+// Adds the "create" query to the query sequence.
+TableCompiler_PG.prototype.createQuery = function (columns, ifNot) {
+  const createStatement = ifNot
+    ? 'create table if not exists '
+    : 'create table ';
+  let sql =
+    createStatement + this.tableName() + ' (' + columns.sql.join(', ') + ')';
+  if (this.single.inherits)
+    sql += ` inherits (${this.formatter.wrap(this.single.inherits)})`;
+  this.pushQuery({
+    sql,
+    bindings: columns.bindings,
+  });
+  const hasComment = has(this.single, 'comment');
+  if (hasComment) this.comment(this.single.comment);
+};
+
+TableCompiler_PG.prototype.addColumns = function (
+  columns,
+  prefix,
+  colCompilers
+) {
+  if (prefix === this.alterColumnsPrefix) {
+    // alter columns
+    for (const col of colCompilers) {
+      const quotedTableName = this.tableName();
+      const type = col.getColumnType();
+      // We'd prefer to call this.formatter.wrapAsIdentifier here instead, however the context passed to
+      // `this` instance is not that of the column, but of the table. Thus, we unfortunately have to call
+      // `wrapIdentifier` here as well (it is already called once on the initial column operation) to give
+      // our `alter` operation the correct `queryContext`. Refer to issue #2606 and PR #2612.
+      const colName = this.client.wrapIdentifier(
+        col.getColumnName(),
+        col.columnBuilder.queryContext()
+      );
+
+      this.pushQuery({
+        sql: `alter table ${quotedTableName} alter column ${colName} drop default`,
+        bindings: [],
+      });
+      this.pushQuery({
+        sql: `alter table ${quotedTableName} alter column ${colName} drop not null`,
+        bindings: [],
+      });
+      this.pushQuery({
+        sql: `alter table ${quotedTableName} alter column ${colName} type ${type} using (${colName}::${type})`,
+        bindings: [],
+      });
+
+      const defaultTo = col.modified['defaultTo'];
+      if (defaultTo) {
+        const modifier = col.defaultTo.apply(col, defaultTo);
+        this.pushQuery({
+          sql: `alter table ${quotedTableName} alter column ${colName} set ${modifier}`,
+          bindings: [],
+        });
+      }
+
+      const nullable = col.modified['nullable'];
+      if (nullable && nullable[0] === false) {
+        this.pushQuery({
+          sql: `alter table ${quotedTableName} alter column ${colName} set not null`,
+          bindings: [],
+        });
+      }
+    }
+  } else {
+    // base class implementation for normal add
+    TableCompiler.prototype.addColumns.call(this, columns, prefix);
+  }
+};
+
+// Compiles the comment on the table.
+TableCompiler_PG.prototype.comment = function (comment) {
+  this.pushQuery(
+    `comment on table ${this.tableName()} is '${this.single.comment}'`
+  );
+};
+
+// Indexes:
+// -------
+
+TableCompiler_PG.prototype.primary = function (columns, constraintName) {
+  constraintName = constraintName
+    ? this.formatter.wrap(constraintName)
+    : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
+  this.pushQuery(
+    `alter table ${this.tableName()} add constraint ${constraintName} primary key (${this.formatter.columnize(
+      columns
+    )})`
+  );
+};
+TableCompiler_PG.prototype.unique = function (columns, indexName) {
+  indexName = indexName
+    ? this.formatter.wrap(indexName)
+    : this._indexCommand('unique', this.tableNameRaw, columns);
+  this.pushQuery(
+    `alter table ${this.tableName()} add constraint ${indexName}` +
+      ' unique (' +
+      this.formatter.columnize(columns) +
+      ')'
+  );
+};
+TableCompiler_PG.prototype.index = function (columns, indexName, indexType) {
+  indexName = indexName
+    ? this.formatter.wrap(indexName)
+    : this._indexCommand('index', this.tableNameRaw, columns);
+  this.pushQuery(
+    `create index ${indexName} on ${this.tableName()}${
+      (indexType && ` using ${indexType}`) || ''
+    }` +
+      ' (' +
+      this.formatter.columnize(columns) +
+      ')'
+  );
+};
+TableCompiler_PG.prototype.dropPrimary = function (constraintName) {
+  constraintName = constraintName
+    ? this.formatter.wrap(constraintName)
+    : this.formatter.wrap(this.tableNameRaw + '_pkey');
+  this.pushQuery(
+    `alter table ${this.tableName()} drop constraint ${constraintName}`
+  );
+};
+TableCompiler_PG.prototype.dropIndex = function (columns, indexName) {
+  indexName = indexName
+    ? this.formatter.wrap(indexName)
+    : this._indexCommand('index', this.tableNameRaw, columns);
+  indexName = this.schemaNameRaw
+    ? `${this.formatter.wrap(this.schemaNameRaw)}.${indexName}`
+    : indexName;
+  this.pushQuery(`drop index ${indexName}`);
+};
+TableCompiler_PG.prototype.dropUnique = function (columns, indexName) {
+  indexName = indexName
+    ? this.formatter.wrap(indexName)
+    : this._indexCommand('unique', this.tableNameRaw, columns);
+  this.pushQuery(
+    `alter table ${this.tableName()} drop constraint ${indexName}`
+  );
+};
+TableCompiler_PG.prototype.dropForeign = function (columns, indexName) {
+  indexName = indexName
+    ? this.formatter.wrap(indexName)
+    : this._indexCommand('foreign', this.tableNameRaw, columns);
+  this.pushQuery(
+    `alter table ${this.tableName()} drop constraint ${indexName}`
+  );
+};
+
+module.exports = TableCompiler_PG;