knex 0.21.20 → 0.21.21

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

@@ -1,206 +1,206 @@
-// PostgreSQL Query Builder & Compiler
-// ------
-const QueryCompiler = require('../../../query/compiler');
-
-const identity = require('lodash/identity');
-const reduce = require('lodash/reduce');
-
-class QueryCompiler_PG extends QueryCompiler {
-  constructor(client, builder) {
-    super(client, builder);
-    this._defaultInsertValue = 'default';
-  }
-
-  // Compiles a truncate query.
-  truncate() {
-    return `truncate ${this.tableName} restart identity`;
-  }
-
-  // is used if the an array with multiple empty values supplied
-
-  // Compiles an `insert` query, allowing for multiple
-  // inserts using a single query statement.
-  insert() {
-    let sql = QueryCompiler.prototype.insert.call(this);
-    if (sql === '') return sql;
-
-    const { returning, onConflict, ignore, merge, insert } = this.single;
-    if (onConflict && ignore) sql += this._ignore(onConflict);
-    if (onConflict && merge) {
-      sql += this._merge(merge.updates, onConflict, insert);
-      const wheres = this.where();
-      if (wheres) sql += ` ${wheres}`;
-    }
-    if (returning) sql += this._returning(returning);
-
-    return {
-      sql: sql,
-      returning,
-    };
-  }
-
-  // Compiles an `update` query, allowing for a return value.
-  update() {
-    const withSQL = this.with();
-    const updateData = this._prepUpdate(this.single.update);
-    const wheres = this.where();
-    const { returning } = this.single;
-    return {
-      sql:
-        withSQL +
-        `update ${this.single.only ? 'only ' : ''}${this.tableName} ` +
-        `set ${updateData.join(', ')}` +
-        (wheres ? ` ${wheres}` : '') +
-        this._returning(returning),
-      returning,
-    };
-  }
-
-  // Compiles an `update` query, allowing for a return value.
-  del() {
-    const sql = QueryCompiler.prototype.del.apply(this, arguments);
-    const { returning } = this.single;
-    return {
-      sql: sql + this._returning(returning),
-      returning,
-    };
-  }
-
-  aggregate(stmt) {
-    return this._aggregate(stmt, { distinctParentheses: true });
-  }
-
-  _returning(value) {
-    return value ? ` returning ${this.formatter.columnize(value)}` : '';
-  }
-
-  _ignore(columns) {
-    return ` on conflict (${this.formatter.columnize(columns)}) do nothing`;
-  }
-
-  _merge(updates, columns, insert) {
-    let sql = ` on conflict (${this.formatter.columnize(
-      columns
-    )}) do update set `;
-    if (updates) {
-      const updateData = this._prepUpdate(updates);
-      if (typeof updateData === 'string') {
-        sql += updateData;
-      } else {
-        sql += updateData.join(',');
-      }
-
-      return sql;
-    } else {
-      const insertData = this._prepInsert(insert);
-      if (typeof insertData === 'string') {
-        throw new Error(
-          'If using merge with a raw insert query, then updates must be provided'
-        );
-      }
-
-      sql += insertData.columns
-        .map((column) => this.formatter.wrapString(column.split('.').pop()))
-        .map((column) => `${column} = excluded.${column}`)
-        .join(', ');
-
-      return sql;
-    }
-  }
-
-  // Join array of table names and apply default schema.
-  _tableNames(tables) {
-    const schemaName = this.single.schema;
-    const sql = [];
-
-    for (let i = 0; i < tables.length; i++) {
-      let tableName = tables[i];
-
-      if (tableName) {
-        if (schemaName) {
-          tableName = `${schemaName}.${tableName}`;
-        }
-        sql.push(this.formatter.wrap(tableName));
-      }
-    }
-
-    return sql.join(', ');
-  }
-
-  forUpdate() {
-    const tables = this.single.lockTables || [];
-
-    return (
-      'for update' + (tables.length ? ' of ' + this._tableNames(tables) : '')
-    );
-  }
-
-  forShare() {
-    const tables = this.single.lockTables || [];
-
-    return (
-      'for share' + (tables.length ? ' of ' + this._tableNames(tables) : '')
-    );
-  }
-
-  skipLocked() {
-    return 'skip locked';
-  }
-
-  noWait() {
-    return 'nowait';
-  }
-
-  // Compiles a columnInfo query
-  columnInfo() {
-    const column = this.single.columnInfo;
-    let schema = this.single.schema;
-
-    // The user may have specified a custom wrapIdentifier function in the config. We
-    // need to run the identifiers through that function, but not format them as
-    // identifiers otherwise.
-    const table = this.client.customWrapIdentifier(this.single.table, identity);
-
-    if (schema) {
-      schema = this.client.customWrapIdentifier(schema, identity);
-    }
-
-    let sql =
-      'select * from information_schema.columns where table_name = ? and table_catalog = ?';
-    const bindings = [table, this.client.database()];
-
-    if (schema) {
-      sql += ' and table_schema = ?';
-      bindings.push(schema);
-    } else {
-      sql += ' and table_schema = current_schema()';
-    }
-
-    return {
-      sql,
-      bindings,
-      output(resp) {
-        const out = reduce(
-          resp.rows,
-          function (columns, val) {
-            columns[val.column_name] = {
-              type: val.data_type,
-              maxLength: val.character_maximum_length,
-              nullable: val.is_nullable === 'YES',
-              defaultValue: val.column_default,
-            };
-            return columns;
-          },
-          {}
-        );
-        return (column && out[column]) || out;
-      },
-    };
-  }
-
-  distinctOn(value) {
-    return 'distinct on (' + this.formatter.columnize(value) + ') ';
-  }
-}
-
-module.exports = QueryCompiler_PG;
+// PostgreSQL Query Builder & Compiler
+// ------
+const QueryCompiler = require('../../../query/compiler');
+
+const identity = require('lodash/identity');
+const reduce = require('lodash/reduce');
+
+class QueryCompiler_PG extends QueryCompiler {
+  constructor(client, builder) {
+    super(client, builder);
+    this._defaultInsertValue = 'default';
+  }
+
+  // Compiles a truncate query.
+  truncate() {
+    return `truncate ${this.tableName} restart identity`;
+  }
+
+  // is used if the an array with multiple empty values supplied
+
+  // Compiles an `insert` query, allowing for multiple
+  // inserts using a single query statement.
+  insert() {
+    let sql = QueryCompiler.prototype.insert.call(this);
+    if (sql === '') return sql;
+
+    const { returning, onConflict, ignore, merge, insert } = this.single;
+    if (onConflict && ignore) sql += this._ignore(onConflict);
+    if (onConflict && merge) {
+      sql += this._merge(merge.updates, onConflict, insert);
+      const wheres = this.where();
+      if (wheres) sql += ` ${wheres}`;
+    }
+    if (returning) sql += this._returning(returning);
+
+    return {
+      sql: sql,
+      returning,
+    };
+  }
+
+  // Compiles an `update` query, allowing for a return value.
+  update() {
+    const withSQL = this.with();
+    const updateData = this._prepUpdate(this.single.update);
+    const wheres = this.where();
+    const { returning } = this.single;
+    return {
+      sql:
+        withSQL +
+        `update ${this.single.only ? 'only ' : ''}${this.tableName} ` +
+        `set ${updateData.join(', ')}` +
+        (wheres ? ` ${wheres}` : '') +
+        this._returning(returning),
+      returning,
+    };
+  }
+
+  // Compiles an `update` query, allowing for a return value.
+  del() {
+    const sql = QueryCompiler.prototype.del.apply(this, arguments);
+    const { returning } = this.single;
+    return {
+      sql: sql + this._returning(returning),
+      returning,
+    };
+  }
+
+  aggregate(stmt) {
+    return this._aggregate(stmt, { distinctParentheses: true });
+  }
+
+  _returning(value) {
+    return value ? ` returning ${this.formatter.columnize(value)}` : '';
+  }
+
+  _ignore(columns) {
+    return ` on conflict (${this.formatter.columnize(columns)}) do nothing`;
+  }
+
+  _merge(updates, columns, insert) {
+    let sql = ` on conflict (${this.formatter.columnize(
+      columns
+    )}) do update set `;
+    if (updates) {
+      const updateData = this._prepUpdate(updates);
+      if (typeof updateData === 'string') {
+        sql += updateData;
+      } else {
+        sql += updateData.join(',');
+      }
+
+      return sql;
+    } else {
+      const insertData = this._prepInsert(insert);
+      if (typeof insertData === 'string') {
+        throw new Error(
+          'If using merge with a raw insert query, then updates must be provided'
+        );
+      }
+
+      sql += insertData.columns
+        .map((column) => this.formatter.wrapString(column.split('.').pop()))
+        .map((column) => `${column} = excluded.${column}`)
+        .join(', ');
+
+      return sql;
+    }
+  }
+
+  // Join array of table names and apply default schema.
+  _tableNames(tables) {
+    const schemaName = this.single.schema;
+    const sql = [];
+
+    for (let i = 0; i < tables.length; i++) {
+      let tableName = tables[i];
+
+      if (tableName) {
+        if (schemaName) {
+          tableName = `${schemaName}.${tableName}`;
+        }
+        sql.push(this.formatter.wrap(tableName));
+      }
+    }
+
+    return sql.join(', ');
+  }
+
+  forUpdate() {
+    const tables = this.single.lockTables || [];
+
+    return (
+      'for update' + (tables.length ? ' of ' + this._tableNames(tables) : '')
+    );
+  }
+
+  forShare() {
+    const tables = this.single.lockTables || [];
+
+    return (
+      'for share' + (tables.length ? ' of ' + this._tableNames(tables) : '')
+    );
+  }
+
+  skipLocked() {
+    return 'skip locked';
+  }
+
+  noWait() {
+    return 'nowait';
+  }
+
+  // Compiles a columnInfo query
+  columnInfo() {
+    const column = this.single.columnInfo;
+    let schema = this.single.schema;
+
+    // The user may have specified a custom wrapIdentifier function in the config. We
+    // need to run the identifiers through that function, but not format them as
+    // identifiers otherwise.
+    const table = this.client.customWrapIdentifier(this.single.table, identity);
+
+    if (schema) {
+      schema = this.client.customWrapIdentifier(schema, identity);
+    }
+
+    let sql =
+      'select * from information_schema.columns where table_name = ? and table_catalog = ?';
+    const bindings = [table, this.client.database()];
+
+    if (schema) {
+      sql += ' and table_schema = ?';
+      bindings.push(schema);
+    } else {
+      sql += ' and table_schema = current_schema()';
+    }
+
+    return {
+      sql,
+      bindings,
+      output(resp) {
+        const out = reduce(
+          resp.rows,
+          function (columns, val) {
+            columns[val.column_name] = {
+              type: val.data_type,
+              maxLength: val.character_maximum_length,
+              nullable: val.is_nullable === 'YES',
+              defaultValue: val.column_default,
+            };
+            return columns;
+          },
+          {}
+        );
+        return (column && out[column]) || out;
+      },
+    };
+  }
+
+  distinctOn(value) {
+    return 'distinct on (' + this.formatter.columnize(value) + ') ';
+  }
+}
+
+module.exports = QueryCompiler_PG;

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

@@ -1,125 +1,125 @@
-// PostgreSQL Column Compiler
-// -------
-
-const { inherits } = require('util');
-const ColumnCompiler = require('../../../schema/columncompiler');
-const { isObject } = require('../../../util/is');
-const commentEscapeRegex = /(?<!')'(?!')/g;
-
-function ColumnCompiler_PG() {
-  ColumnCompiler.apply(this, arguments);
-  this.modifiers = ['nullable', 'defaultTo', 'comment'];
-}
-inherits(ColumnCompiler_PG, ColumnCompiler);
-
-Object.assign(ColumnCompiler_PG.prototype, {
-  // Types
-  // ------
-  bigincrements: 'bigserial primary key',
-  bigint: 'bigint',
-  binary: 'bytea',
-
-  bit(column) {
-    return column.length !== false ? `bit(${column.length})` : 'bit';
-  },
-
-  bool: 'boolean',
-
-  // Create the column definition for an enum type.
-  // Using method "2" here: http://stackoverflow.com/a/10984951/525714
-  enu(allowed, options) {
-    options = options || {};
-
-    const values =
-      options.useNative && options.existingType
-        ? undefined
-        : allowed.join("', '");
-
-    if (options.useNative) {
-      let enumName = '';
-      const schemaName = options.schemaName || this.tableCompiler.schemaNameRaw;
-
-      if (schemaName) {
-        enumName += `"${schemaName}".`;
-      }
-
-      enumName += `"${options.enumName}"`;
-
-      if (!options.existingType) {
-        this.tableCompiler.unshiftQuery(
-          `create type ${enumName} as enum ('${values}')`
-        );
-      }
-
-      return enumName;
-    }
-    return `text check (${this.formatter.wrap(this.args[0])} in ('${values}'))`;
-  },
-
-  double: 'double precision',
-  decimal(precision, scale) {
-    if (precision === null) return 'decimal';
-    return `decimal(${this._num(precision, 8)}, ${this._num(scale, 2)})`;
-  },
-  floating: 'real',
-  increments: 'serial primary key',
-  json(jsonb) {
-    if (jsonb) this.client.logger.deprecate('json(true)', 'jsonb()');
-    return jsonColumn(this.client, jsonb);
-  },
-  jsonb() {
-    return jsonColumn(this.client, true);
-  },
-  smallint: 'smallint',
-  tinyint: 'smallint',
-  datetime(withoutTz = false, precision) {
-    let useTz;
-    if (isObject(withoutTz)) {
-      ({ useTz, precision } = withoutTz);
-    } else {
-      useTz = !withoutTz;
-    }
-
-    return `${useTz ? 'timestamptz' : 'timestamp'}${
-      precision ? '(' + precision + ')' : ''
-    }`;
-  },
-  timestamp(withoutTz = false, precision) {
-    let useTz;
-    if (isObject(withoutTz)) {
-      ({ useTz, precision } = withoutTz);
-    } else {
-      useTz = !withoutTz;
-    }
-
-    return `${useTz ? 'timestamptz' : 'timestamp'}${
-      precision ? '(' + precision + ')' : ''
-    }`;
-  },
-  uuid: 'uuid',
-
-  // Modifiers:
-  // ------
-  comment(comment) {
-    const columnName = this.args[0] || this.defaults('columnName');
-    const escapedComment = comment
-      ? `'${comment.replace(commentEscapeRegex, "''")}'`
-      : 'NULL';
-
-    this.pushAdditional(function () {
-      this.pushQuery(
-        `comment on column ${this.tableCompiler.tableName()}.` +
-          this.formatter.wrap(columnName) +
-          ` is ${escapedComment}`
-      );
-    }, comment);
-  },
-});
-
-function jsonColumn(client, jsonb) {
-  if (!client.version || parseFloat(client.version) >= 9.2)
-    return jsonb ? 'jsonb' : 'json';
-  return 'text';
-}
-
-module.exports = ColumnCompiler_PG;
+// PostgreSQL Column Compiler
+// -------
+
+const { inherits } = require('util');
+const ColumnCompiler = require('../../../schema/columncompiler');
+const { isObject } = require('../../../util/is');
+const commentEscapeRegex = /(?<!')'(?!')/g;
+
+function ColumnCompiler_PG() {
+  ColumnCompiler.apply(this, arguments);
+  this.modifiers = ['nullable', 'defaultTo', 'comment'];
+}
+inherits(ColumnCompiler_PG, ColumnCompiler);
+
+Object.assign(ColumnCompiler_PG.prototype, {
+  // Types
+  // ------
+  bigincrements: 'bigserial primary key',
+  bigint: 'bigint',
+  binary: 'bytea',
+
+  bit(column) {
+    return column.length !== false ? `bit(${column.length})` : 'bit';
+  },
+
+  bool: 'boolean',
+
+  // Create the column definition for an enum type.
+  // Using method "2" here: http://stackoverflow.com/a/10984951/525714
+  enu(allowed, options) {
+    options = options || {};
+
+    const values =
+      options.useNative && options.existingType
+        ? undefined
+        : allowed.join("', '");
+
+    if (options.useNative) {
+      let enumName = '';
+      const schemaName = options.schemaName || this.tableCompiler.schemaNameRaw;
+
+      if (schemaName) {
+        enumName += `"${schemaName}".`;
+      }
+
+      enumName += `"${options.enumName}"`;
+
+      if (!options.existingType) {
+        this.tableCompiler.unshiftQuery(
+          `create type ${enumName} as enum ('${values}')`
+        );
+      }
+
+      return enumName;
+    }
+    return `text check (${this.formatter.wrap(this.args[0])} in ('${values}'))`;
+  },
+
+  double: 'double precision',
+  decimal(precision, scale) {
+    if (precision === null) return 'decimal';
+    return `decimal(${this._num(precision, 8)}, ${this._num(scale, 2)})`;
+  },
+  floating: 'real',
+  increments: 'serial primary key',
+  json(jsonb) {
+    if (jsonb) this.client.logger.deprecate('json(true)', 'jsonb()');
+    return jsonColumn(this.client, jsonb);
+  },
+  jsonb() {
+    return jsonColumn(this.client, true);
+  },
+  smallint: 'smallint',
+  tinyint: 'smallint',
+  datetime(withoutTz = false, precision) {
+    let useTz;
+    if (isObject(withoutTz)) {
+      ({ useTz, precision } = withoutTz);
+    } else {
+      useTz = !withoutTz;
+    }
+
+    return `${useTz ? 'timestamptz' : 'timestamp'}${
+      precision ? '(' + precision + ')' : ''
+    }`;
+  },
+  timestamp(withoutTz = false, precision) {
+    let useTz;
+    if (isObject(withoutTz)) {
+      ({ useTz, precision } = withoutTz);
+    } else {
+      useTz = !withoutTz;
+    }
+
+    return `${useTz ? 'timestamptz' : 'timestamp'}${
+      precision ? '(' + precision + ')' : ''
+    }`;
+  },
+  uuid: 'uuid',
+
+  // Modifiers:
+  // ------
+  comment(comment) {
+    const columnName = this.args[0] || this.defaults('columnName');
+    const escapedComment = comment
+      ? `'${comment.replace(commentEscapeRegex, "''")}'`
+      : 'NULL';
+
+    this.pushAdditional(function () {
+      this.pushQuery(
+        `comment on column ${this.tableCompiler.tableName()}.` +
+          this.formatter.wrap(columnName) +
+          ` is ${escapedComment}`
+      );
+    }, comment);
+  },
+});
+
+function jsonColumn(client, jsonb) {
+  if (!client.version || parseFloat(client.version) >= 9.2)
+    return jsonb ? 'jsonb' : 'json';
+  return 'text';
+}
+
+module.exports = ColumnCompiler_PG;