knex 0.95.14 → 1.0.2

package/lib/dialects/mysql/schema/mysql-tablecompiler.js

@@ -19,7 +19,7 @@ class TableCompiler_MySQL extends TableCompiler {
       : 'create table ';
     const { client } = this;
     let conn = {};
-    const columnsSql = ' (' + columns.sql.join(', ') + ')';
+    const columnsSql = ' (' + columns.sql.join(', ') + this._addChecks() + ')';
     let sql =
       createStatement +
       this.tableName() +
@@ -42,14 +42,18 @@ class TableCompiler_MySQL extends TableCompiler {
 
     if (this.single.comment) {
       const comment = this.single.comment || '';
-      if (comment.length > 60)
+      const MAX_COMMENT_LENGTH = 1024;
+      if (comment.length > MAX_COMMENT_LENGTH)
         this.client.logger.warn(
-          'The max length for a table comment is 60 characters'
+          `The max length for a table comment is ${MAX_COMMENT_LENGTH} characters`
         );
       sql += ` comment = '${comment}'`;
     }
 
     this.pushQuery(sql);
+    if (like) {
+      this.addColumns(columns, this.addColumnsPrefix);
+    }
   }
 
   // Compiles the comment on the table.
@@ -69,7 +73,7 @@ class TableCompiler_MySQL extends TableCompiler {
 
     this.pushQuery({
       sql:
-        `show fields from ${table} where field = ` +
+        `show full fields from ${table} where field = ` +
         this.client.parameter(from, this.tableBuilder, this.bindingsHolder),
       output(resp) {
         const column = resp[0];
@@ -97,7 +101,10 @@ class TableCompiler_MySQL extends TableCompiler {
               if (column.Default !== void 0 && column.Default !== null) {
                 sql += ` DEFAULT '${column.Default}'`;
               }
-              // Add back the auto increment if the column had it, fix issue #2767
+              if (column.Collation !== void 0 && column.Collation !== null) {
+                sql += ` COLLATE '${column.Collation}'`;
+              }
+              // Add back the auto increment if the column  it, fix issue #2767
               if (column.Extra == 'auto_increment') {
                 sql += ` AUTO_INCREMENT`;
               }
@@ -249,11 +256,31 @@ class TableCompiler_MySQL extends TableCompiler {
     constraintName = constraintName
       ? this.formatter.wrap(constraintName)
       : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
+
+    const primaryCols = columns;
+    let incrementsCols = [];
+    if (this.grouped.columns) {
+      incrementsCols = this._getIncrementsColumnNames();
+      if (incrementsCols) {
+        incrementsCols.forEach((c) => {
+          if (!primaryCols.includes(c)) {
+            primaryCols.unshift(c);
+          }
+        });
+      }
+    }
     this.pushQuery(
       `alter table ${this.tableName()} add primary key ${constraintName}(${this.formatter.columnize(
-        columns
+        primaryCols
       )})`
     );
+    if (incrementsCols.length) {
+      this.pushQuery(
+        `alter table ${this.tableName()} modify column ${this.formatter.columnize(
+          incrementsCols
+        )} int unsigned not null auto_increment`
+      );
+    }
   }
 
   unique(columns, indexName) {

package/lib/dialects/oracle/query/oracle-querycompiler.js

@@ -315,10 +315,9 @@ class QueryCompiler_Oracle extends QueryCompiler {
     query = query || '';
 
     if (hasLimit && !offset) {
-      return `select * from (${query}) where rownum <= ${this.client.parameter(
-        limit,
-        this.builder,
-        this.bindingsHolder
+      return `select * from (${query}) where rownum <= ${this._getValueOrParameterFromAttribute(
+        'limit',
+        limit
       )}`;
     }
 
@@ -330,10 +329,12 @@ class QueryCompiler_Oracle extends QueryCompiler {
       query +
       ') row_ ' +
       'where rownum <= ' +
-      this.client.parameter(endRow, this.builder, this.bindingsHolder) +
+      (this.single.skipBinding['offset']
+        ? endRow
+        : this.client.parameter(endRow, this.builder, this.bindingsHolder)) +
       ') ' +
       'where rownum_ > ' +
-      this.client.parameter(offset, this.builder, this.bindingsHolder)
+      this._getValueOrParameterFromAttribute('offset', offset)
     );
   }
 }

package/lib/dialects/oracle/schema/internal/trigger.js

@@ -64,7 +64,7 @@ const trigger = {
       `PK_NAME VARCHAR(200); ` +
       `BEGIN` +
       `  EXECUTE IMMEDIATE ('CREATE SEQUENCE ${schemaQuoted}${sequenceNameQuoted}');` +
-      `  SELECT cols.column_name INTO PK_NAME` +
+      `  SELECT cols.column_name INTO PK_NAME` + // TODO : support autoincrement on table with multiple primary keys
       `  FROM all_constraints cons, all_cons_columns cols` +
       `  WHERE cons.constraint_type = 'P'` +
       `  AND cons.constraint_name = cols.constraint_name` +

package/lib/dialects/oracle/schema/oracle-columncompiler.js

@@ -15,14 +15,20 @@ class ColumnCompiler_Oracle extends ColumnCompiler {
     this.modifiers = ['defaultTo', 'checkIn', 'nullable', 'comment'];
   }
 
-  increments({ primaryKey = true } = {}) {
+  increments(options = { primaryKey: true }) {
     createAutoIncrementTriggerAndSequence(this);
-    return 'integer not null' + (primaryKey ? ' primary key' : '');
+    return (
+      'integer not null' +
+      (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '')
+    );
   }
 
-  bigincrements({ primaryKey = true } = {}) {
+  bigincrements(options = { primaryKey: true }) {
     createAutoIncrementTriggerAndSequence(this);
-    return 'number(20, 0) not null' + (primaryKey ? ' primary key' : '');
+    return (
+      'number(20, 0) not null' +
+      (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '')
+    );
   }
 
   floating(precision) {

package/lib/dialects/oracle/schema/oracle-tablecompiler.js

@@ -57,7 +57,7 @@ class TableCompiler_Oracle extends TableCompiler {
     const columnsSql =
       like && this.tableNameLike()
         ? ' as (select * from ' + this.tableNameLike() + ' where 0=1)'
-        : ' (' + columns.sql.join(', ') + ')';
+        : ' (' + columns.sql.join(', ') + this._addChecks() + ')';
     const sql = `create table ${this.tableName()}${columnsSql}`;
 
     this.pushQuery({
@@ -66,6 +66,9 @@ class TableCompiler_Oracle extends TableCompiler {
       bindings: columns.bindings,
     });
     if (this.single.comment) this.comment(this.single.comment);
+    if (like) {
+      this.addColumns(columns, this.addColumnsPrefix);
+    }
   }
 
   // Compiles the comment on the table.
@@ -82,10 +85,6 @@ class TableCompiler_Oracle extends TableCompiler {
     );
   }
 
-  changeType() {
-    // alter table + table + ' modify ' + wrapped + '// type';
-  }
-
   _indexCommand(type, tableName, columns) {
     return this.formatter.wrap(
       utils.generateCombinedName(this.client.logger, type, tableName, columns)
@@ -101,9 +100,21 @@ class TableCompiler_Oracle extends TableCompiler {
     constraintName = constraintName
       ? this.formatter.wrap(constraintName)
       : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
+    const primaryCols = columns;
+    let incrementsCols = [];
+    if (this.grouped.columns) {
+      incrementsCols = this._getIncrementsColumnNames();
+      if (incrementsCols) {
+        incrementsCols.forEach((c) => {
+          if (!primaryCols.includes(c)) {
+            primaryCols.unshift(c);
+          }
+        });
+      }
+    }
     this.pushQuery(
       `alter table ${this.tableName()} add constraint ${constraintName} primary key (${this.formatter.columnize(
-        columns
+        primaryCols
       )})${deferrable}`
     );
   }

package/lib/dialects/oracledb/index.js

@@ -4,7 +4,6 @@ const each = require('lodash/each');
 const flatten = require('lodash/flatten');
 const isEmpty = require('lodash/isEmpty');
 const map = require('lodash/map');
-const values = require('lodash/values');
 
 const Formatter = require('../../formatter');
 const QueryCompiler = require('./query/oracledb-querycompiler');
@@ -288,9 +287,6 @@ class Client_Oracledb extends Client_Oracle {
       case 'update':
       case 'counter':
         if (obj.returning && !isEmpty(obj.returning)) {
-          if (obj.returning.length === 1 && obj.returning[0] !== '*') {
-            return flatten(map(response, values));
-          }
           return response;
         } else if (obj.rowsAffected !== undefined) {
           return obj.rowsAffected;

package/lib/dialects/oracledb/query/oracledb-querycompiler.js

@@ -6,6 +6,9 @@ const Oracle_Compiler = require('../../oracle/query/oracle-querycompiler');
 const ReturningHelper = require('../utils').ReturningHelper;
 const BlobHelper = require('../utils').BlobHelper;
 const { isString } = require('../../../util/is');
+const {
+  columnize: columnize_,
+} = require('../../../formatter/wrappingFormatter');
 
 class Oracledb_Compiler extends Oracle_Compiler {
   // Compiles an "insert" query, allowing for multiple
@@ -312,6 +315,10 @@ class Oracledb_Compiler extends Oracle_Compiler {
     return result;
   }
 
+  _groupOrder(item, type) {
+    return super._groupOrderNulls(item, type);
+  }
+
   update() {
     const self = this;
     const sql = {};
@@ -387,6 +394,88 @@ class Oracledb_Compiler extends Oracle_Compiler {
 
     return sql;
   }
+
+  _jsonPathWrap(extraction) {
+    return `'${extraction.path || extraction[1]}'`;
+  }
+
+  // Json functions
+  jsonExtract(params) {
+    return this._jsonExtract(
+      params.singleValue ? 'json_value' : 'json_query',
+      params
+    );
+  }
+
+  jsonSet(params) {
+    return `json_transform(${columnize_(
+      params.column,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )}, set ${this.client.parameter(
+      params.path,
+      this.builder,
+      this.bindingsHolder
+    )} = ${this.client.parameter(
+      params.value,
+      this.builder,
+      this.bindingsHolder
+    )})`;
+  }
+
+  jsonInsert(params) {
+    return `json_transform(${columnize_(
+      params.column,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )}, insert ${this.client.parameter(
+      params.path,
+      this.builder,
+      this.bindingsHolder
+    )} = ${this.client.parameter(
+      params.value,
+      this.builder,
+      this.bindingsHolder
+    )})`;
+  }
+
+  jsonRemove(params) {
+    const jsonCol = `json_transform(${columnize_(
+      params.column,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )}, remove ${this.client.parameter(
+      params.path,
+      this.builder,
+      this.bindingsHolder
+    )})`;
+    return params.alias
+      ? this.client.alias(jsonCol, this.formatter.wrap(params.alias))
+      : jsonCol;
+  }
+
+  whereJsonPath(statement) {
+    return this._whereJsonPath('json_value', statement);
+  }
+
+  whereJsonSupersetOf(statement) {
+    throw new Error(
+      'Json superset where clause not actually supported by Oracle'
+    );
+  }
+
+  whereJsonSubsetOf(statement) {
+    throw new Error(
+      'Json subset where clause not actually supported by Oracle'
+    );
+  }
+
+  onJsonPathEquals(clause) {
+    return this._onJsonPathEquals('json_value', clause);
+  }
 }
 
 module.exports = Oracledb_Compiler;

package/lib/dialects/oracledb/schema/oracledb-columncompiler.js

@@ -4,6 +4,8 @@ const { isObject } = require('../../../util/is');
 class ColumnCompiler_Oracledb extends ColumnCompiler_Oracle {
   constructor() {
     super(...arguments);
+    this.modifiers = ['defaultTo', 'nullable', 'comment'];
+    this._addCheckModifiers();
   }
 
   datetime(withoutTz) {
@@ -25,8 +27,29 @@ class ColumnCompiler_Oracledb extends ColumnCompiler_Oracle {
     }
     return useTz ? 'timestamp with local time zone' : 'timestamp';
   }
+
+  checkRegex(regex, constraintName) {
+    return this._check(
+      `REGEXP_LIKE(${this.formatter.wrap(
+        this.getColumnName()
+      )},${this.client._escapeBinding(regex)})`,
+      constraintName
+    );
+  }
+
+  json() {
+    return `varchar2(4000) check (${this.formatter.columnize(
+      this.getColumnName()
+    )} is json)`;
+  }
+
+  jsonb() {
+    return this.json();
+  }
 }
 
 ColumnCompiler_Oracledb.prototype.time = 'timestamp with local time zone';
+ColumnCompiler_Oracledb.prototype.uuid = ({ useBinaryUuid = false } = {}) =>
+  useBinaryUuid ? 'raw(16)' : 'char(36)';
 
 module.exports = ColumnCompiler_Oracledb;

package/lib/dialects/postgres/index.js

@@ -7,6 +7,7 @@ const Client = require('../../client');
 
 const Transaction = require('./execution/pg-transaction');
 const QueryCompiler = require('./query/pg-querycompiler');
+const QueryBuilder = require('./query/pg-querybuilder');
 const ColumnCompiler = require('./schema/pg-columncompiler');
 const TableCompiler = require('./schema/pg-tablecompiler');
 const ViewCompiler = require('./schema/pg-viewcompiler');
@@ -30,6 +31,10 @@ class Client_PG extends Client {
     return new Transaction(this, ...arguments);
   }
 
+  queryBuilder() {
+    return new QueryBuilder(this);
+  }
+
   queryCompiler(builder, formatter) {
     return new QueryCompiler(this, builder, formatter);
   }
@@ -241,12 +246,7 @@ class Client_PG extends Client {
       const returns = [];
       for (let i = 0, l = resp.rows.length; i < l; i++) {
         const row = resp.rows[i];
-        if (returning === '*' || Array.isArray(returning)) {
-          returns[i] = row;
-        } else {
-          // Pluck the only column in the row.
-          returns[i] = row[Object.keys(row)[0]];
-        }
+        returns[i] = row;
       }
       return returns;
     }
@@ -274,6 +274,21 @@ class Client_PG extends Client {
       options: {},
     });
   }
+
+  toPathForJson(jsonPath) {
+    const PG_PATH_REGEX = /^{.*}$/;
+    if (jsonPath.match(PG_PATH_REGEX)) {
+      return jsonPath;
+    }
+    return (
+      '{' +
+      jsonPath
+        .replace(/^(\$\.)/, '') // remove the first dollar
+        .replace('.', ',')
+        .replace(/\[([0-9]+)]/, ',$1') + // transform [number] to ,number
+      '}'
+    );
+  }
 }
 
 Object.assign(Client_PG.prototype, {

package/lib/dialects/postgres/query/pg-querybuilder.js

@@ -0,0 +1,38 @@
+const QueryBuilder = require('../../../query/querybuilder.js');
+
+module.exports = class QueryBuilder_PostgreSQL extends QueryBuilder {
+  using(tables) {
+    this._single.using = tables;
+    return this;
+  }
+
+  withMaterialized(alias, statementOrColumnList, nothingOrStatement) {
+    this._validateWithArgs(
+      alias,
+      statementOrColumnList,
+      nothingOrStatement,
+      'with'
+    );
+    return this.withWrapped(
+      alias,
+      statementOrColumnList,
+      nothingOrStatement,
+      true
+    );
+  }
+
+  withNotMaterialized(alias, statementOrColumnList, nothingOrStatement) {
+    this._validateWithArgs(
+      alias,
+      statementOrColumnList,
+      nothingOrStatement,
+      'with'
+    );
+    return this.withWrapped(
+      alias,
+      statementOrColumnList,
+      nothingOrStatement,
+      false
+    );
+  }
+};

package/lib/dialects/postgres/query/pg-querycompiler.js

@@ -4,7 +4,12 @@ const identity = require('lodash/identity');
 const reduce = require('lodash/reduce');
 
 const QueryCompiler = require('../../../query/querycompiler');
-const { wrapString } = require('../../../formatter/wrappingFormatter');
+const {
+  wrapString,
+  columnize: columnize_,
+  operator: operator_,
+  wrap: wrap_,
+} = require('../../../formatter/wrappingFormatter');
 
 class QueryCompiler_PG extends QueryCompiler {
   constructor(client, builder, formatter) {
@@ -35,7 +40,7 @@ class QueryCompiler_PG extends QueryCompiler {
     if (returning) sql += this._returning(returning);
 
     return {
-      sql: sql,
+      sql,
       returning,
     };
   }
@@ -57,9 +62,70 @@ class QueryCompiler_PG extends QueryCompiler {
     };
   }
 
-  // Compiles an `update` query, allowing for a return value.
+  using() {
+    const usingTables = this.single.using;
+    if (!usingTables) return;
+    let sql = 'using ';
+    if (Array.isArray(usingTables)) {
+      sql += usingTables
+        .map((table) => {
+          return this.formatter.wrap(table);
+        })
+        .join(',');
+    } else {
+      sql += this.formatter.wrap(usingTables);
+    }
+    return sql;
+  }
+
+  // Compiles an `delete` query, allowing for a return value.
   del() {
-    const sql = super.del(...arguments);
+    // Make sure tableName is processed by the formatter first.
+    const { tableName } = this;
+    const withSQL = this.with();
+    let wheres = this.where() || '';
+    let using = this.using() || '';
+    const joins = this.grouped.join;
+
+    const tableJoins = [];
+    if (Array.isArray(joins)) {
+      for (const join of joins) {
+        tableJoins.push(
+          wrap_(
+            this._joinTable(join),
+            undefined,
+            this.builder,
+            this.client,
+            this.bindingsHolder
+          )
+        );
+
+        const joinWheres = [];
+        for (const clause of join.clauses) {
+          joinWheres.push(
+            this.whereBasic({
+              column: clause.column,
+              operator: '=',
+              value: clause.value,
+              asColumn: true,
+            })
+          );
+        }
+        if (joinWheres.length > 0) {
+          wheres += (wheres ? ' and ' : '') + joinWheres.join(' ');
+        }
+      }
+      if (tableJoins.length > 0) {
+        using += (using ? ',' : 'using ') + tableJoins.join(',');
+      }
+    }
+
+    // With 'using' syntax, no tablename between DELETE and FROM.
+    const sql =
+      withSQL +
+      `delete from ${this.single.only ? 'only ' : ''}${tableName}` +
+      (using ? ` ${using}` : '') +
+      (wheres ? ` ${wheres}` : '');
     const { returning } = this.single;
     return {
       sql: sql + this._returning(returning),
@@ -79,13 +145,11 @@ class QueryCompiler_PG extends QueryCompiler {
     if (columns === true) {
       return ' on conflict do nothing';
     }
-    return ` on conflict (${this.formatter.columnize(columns)}) do nothing`;
+    return ` on conflict ${this._onConflictClause(columns)} do nothing`;
   }
 
   _merge(updates, columns, insert) {
-    let sql = ` on conflict (${this.formatter.columnize(
-      columns
-    )}) do update set `;
+    let sql = ` on conflict ${this._onConflictClause(columns)} do update set `;
     if (updates && Array.isArray(updates)) {
       sql += updates
         .map((column) =>
@@ -153,6 +217,10 @@ class QueryCompiler_PG extends QueryCompiler {
     return lockMode + (tables.length ? ' of ' + this._tableNames(tables) : '');
   }
 
+  _groupOrder(item, type) {
+    return super._groupOrderNulls(item, type);
+  }
+
   forUpdate() {
     return this._lockingClause('for update');
   }
@@ -191,10 +259,14 @@ class QueryCompiler_PG extends QueryCompiler {
       schema = this.client.customWrapIdentifier(schema, identity);
     }
 
-    let sql =
+    const sql =
       'select * from information_schema.columns where table_name = ? and table_catalog = current_database()';
     const bindings = [table];
 
+    return this._buildColumnInfoQuery(schema, sql, bindings, column);
+  }
+
+  _buildColumnInfoQuery(schema, sql, bindings, column) {
     if (schema) {
       sql += ' and table_schema = ?';
       bindings.push(schema);
@@ -227,6 +299,97 @@ class QueryCompiler_PG extends QueryCompiler {
   distinctOn(value) {
     return 'distinct on (' + this.formatter.columnize(value) + ') ';
   }
+
+  // Json functions
+  jsonExtract(params) {
+    return this._jsonExtract('jsonb_path_query', params);
+  }
+
+  jsonSet(params) {
+    return this._jsonSet(
+      'jsonb_set',
+      Object.assign({}, params, {
+        path: this.client.toPathForJson(params.path),
+      })
+    );
+  }
+
+  jsonInsert(params) {
+    return this._jsonSet(
+      'jsonb_insert',
+      Object.assign({}, params, {
+        path: this.client.toPathForJson(params.path),
+      })
+    );
+  }
+
+  jsonRemove(params) {
+    const jsonCol = `${columnize_(
+      params.column,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )} #- ${this.client.parameter(
+      this.client.toPathForJson(params.path),
+      this.builder,
+      this.bindingsHolder
+    )}`;
+    return params.alias
+      ? this.client.alias(jsonCol, this.formatter.wrap(params.alias))
+      : jsonCol;
+  }
+
+  whereJsonPath(statement) {
+    let castValue = '';
+    if (parseInt(statement.value)) {
+      castValue = '::int';
+    } else if (parseFloat(statement.value)) {
+      castValue = '::float';
+    } else {
+      castValue = " #>> '{}'";
+    }
+    return `jsonb_path_query_first(${this._columnClause(
+      statement
+    )}, ${this.client.parameter(
+      statement.jsonPath,
+      this.builder,
+      this.bindingsHolder
+    )})${castValue} ${operator_(
+      statement.operator,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )} ${this._jsonValueClause(statement)}`;
+  }
+
+  whereJsonSupersetOf(statement) {
+    return this._not(
+      statement,
+      `${wrap_(
+        statement.column,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      )} @> ${this._jsonValueClause(statement)}`
+    );
+  }
+
+  whereJsonSubsetOf(statement) {
+    return this._not(
+      statement,
+      `${columnize_(
+        statement.column,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      )} <@ ${this._jsonValueClause(statement)}`
+    );
+  }
+
+  onJsonPathEquals(clause) {
+    return this._onJsonPathEquals('jsonb_path_query_first', clause);
+  }
 }
 
 module.exports = QueryCompiler_PG;