knex 0.95.13 → 1.0.1

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

@@ -44,12 +44,16 @@ class TableCompiler_PG extends TableCompiler {
     const createStatement = ifNot
       ? 'create table if not exists '
       : 'create table ';
-    const columnsSql = ' (' + columns.sql.join(', ') + ')';
+    const columnsSql = ' (' + columns.sql.join(', ') + this._addChecks() + ')';
     let sql =
       createStatement +
       this.tableName() +
       (like && this.tableNameLike()
-        ? ' (like ' + this.tableNameLike() + ' including all)'
+        ? ' (like ' +
+          this.tableNameLike() +
+          ' including all' +
+          (columns.sql.length ? ', ' + columns.sql.join(', ') : '') +
+          ')'
         : columnsSql);
     if (this.single.inherits)
       sql += ` inherits (${this.formatter.wrap(this.single.inherits)})`;
@@ -65,51 +69,7 @@ class TableCompiler_PG extends TableCompiler {
     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()
-        );
-
-        // To alter enum columns they must be cast to text first
-        const isEnum = col.type === 'enu';
-
-        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}${
-            isEnum ? '::text::' : '::'
-          }${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: [],
-          });
-        }
+        this._addColumn(col);
       }
     } else {
       // base class implementation for normal add
@@ -117,6 +77,54 @@ class TableCompiler_PG extends TableCompiler {
     }
   }
 
+  _addColumn(col) {
+    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()
+    );
+
+    // To alter enum columns they must be cast to text first
+    const isEnum = col.type === 'enu';
+
+    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}${
+        isEnum ? '::text::' : '::'
+      }${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: [],
+      });
+    }
+  }
+
   // Compiles the comment on the table.
   comment(comment) {
     this.pushQuery(

package/lib/dialects/redshift/index.js

@@ -63,6 +63,18 @@ class Client_Redshift extends Client_PG {
     }
     return resp;
   }
+
+  toPathForJson(jsonPath, builder, bindingsHolder) {
+    return jsonPath
+      .replace(/^(\$\.)/, '') // remove the first dollar
+      .split('.')
+      .map(
+        function (v) {
+          return this.parameter(v, builder, bindingsHolder);
+        }.bind(this)
+      )
+      .join(', ');
+  }
 }
 
 Object.assign(Client_Redshift.prototype, {

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

@@ -4,7 +4,9 @@ const QueryCompiler = require('../../../query/querycompiler');
 const QueryCompiler_PG = require('../../postgres/query/pg-querycompiler');
 
 const identity = require('lodash/identity');
-const reduce = require('lodash/reduce');
+const {
+  columnize: columnize_,
+} = require('../../../formatter/wrappingFormatter');
 
 class QueryCompiler_Redshift extends QueryCompiler_PG {
   truncate() {
@@ -87,40 +89,74 @@ class QueryCompiler_Redshift extends QueryCompiler_PG {
       schema = this.client.customWrapIdentifier(schema, identity);
     }
 
-    let sql =
+    const sql =
       'select * from information_schema.columns where table_name = ? and table_catalog = ?';
     const bindings = [
       table.toLowerCase(),
       this.client.database().toLowerCase(),
     ];
 
-    if (schema) {
-      sql += ' and table_schema = ?';
-      bindings.push(schema);
+    return this._buildColumnInfoQuery(schema, sql, bindings, column);
+  }
+
+  jsonExtract(params) {
+    let extractions;
+    if (Array.isArray(params.column)) {
+      extractions = params.column;
     } else {
-      sql += ' and table_schema = current_schema()';
+      extractions = [params];
     }
+    return extractions
+      .map((extraction) => {
+        const jsonCol = `json_extract_path_text(${columnize_(
+          extraction.column || extraction[0],
+          this.builder,
+          this.client,
+          this.bindingsHolder
+        )}, ${this.client.toPathForJson(
+          params.path || extraction[1],
+          this.builder,
+          this.bindingsHolder
+        )})`;
+        const alias = extraction.alias || extraction[2];
+        return alias
+          ? this.client.alias(jsonCol, this.formatter.wrap(alias))
+          : jsonCol;
+      })
+      .join(', ');
+  }
 
-    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;
-      },
-    };
+  jsonSet(params) {
+    throw new Error('Json set is not supported by Redshift');
+  }
+
+  jsonInsert(params) {
+    throw new Error('Json insert is not supported by Redshift');
+  }
+
+  jsonRemove(params) {
+    throw new Error('Json remove is not supported by Redshift');
+  }
+
+  whereJsonPath(statement) {
+    return this._whereJsonPath(
+      'json_extract_path_text',
+      Object.assign({}, statement, {
+        path: this.client.toPathForJson(statement.path),
+      })
+    );
+  }
+
+  whereJsonSupersetOf(statement) {
+    throw new Error('Json superset is not supported by Redshift');
+  }
+
+  whereJsonSubsetOf(statement) {
+    throw new Error('Json subset is not supported by Redshift');
+  }
+
+  onJsonPathEquals(clause) {
+    return this._onJsonPathEquals('json_extract_path_text', clause);
   }
 }
 

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

@@ -2,6 +2,7 @@
 // -------
 
 const ColumnCompiler_PG = require('../../postgres/schema/pg-columncompiler');
+const ColumnCompiler = require('../../../schema/columncompiler');
 
 class ColumnCompiler_Redshift extends ColumnCompiler_PG {
   constructor() {
@@ -54,7 +55,7 @@ ColumnCompiler_Redshift.prototype.mediumblob = 'varchar(16777218)';
 ColumnCompiler_Redshift.prototype.set = 'text';
 ColumnCompiler_Redshift.prototype.text = 'varchar(max)';
 ColumnCompiler_Redshift.prototype.tinyblob = 'varchar(256)';
-ColumnCompiler_Redshift.prototype.uuid = 'char(36)';
+ColumnCompiler_Redshift.prototype.uuid = ColumnCompiler.prototype.uuid;
 ColumnCompiler_Redshift.prototype.varbinary = 'varchar(max)';
 ColumnCompiler_Redshift.prototype.bigint = 'bigint';
 ColumnCompiler_Redshift.prototype.bool = 'boolean';

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

@@ -30,7 +30,7 @@ class TableCompiler_Redshift extends TableCompiler_PG {
     const createStatement = ifNot
       ? 'create table if not exists '
       : 'create table ';
-    const columnsSql = ' (' + columns.sql.join(', ') + ')';
+    const columnsSql = ' (' + columns.sql.join(', ') + this._addChecks() + ')';
     let sql =
       createStatement +
       this.tableName() +
@@ -45,6 +45,9 @@ class TableCompiler_Redshift extends TableCompiler_PG {
     });
     const hasComment = has(this.single, 'comment');
     if (hasComment) this.comment(this.single.comment);
+    if (like) {
+      this.addColumns(columns, this.addColumnsPrefix);
+    }
   }
 
   primary(columns, constraintName) {

package/lib/dialects/sqlite3/index.js

@@ -29,7 +29,7 @@ class Client_SQLite3 extends Client {
   }
 
   _driver() {
-    return require('sqlite3');
+    return require('@vscode/sqlite3');
   }
 
   schemaCompiler() {
@@ -132,6 +132,7 @@ class Client_SQLite3 extends Client {
         // We need the context here, as it contains
         // the "this.lastID" or "this.changes"
         obj.context = this;
+
         return resolver(obj);
       });
     });
@@ -144,6 +145,7 @@ class Client_SQLite3 extends Client {
     return new Promise(function (resolver, rejecter) {
       stream.on('error', rejecter);
       stream.on('end', resolver);
+
       return client
         ._query(connection, obj)
         .then((obj) => obj.response)
@@ -160,7 +162,7 @@ class Client_SQLite3 extends Client {
   // Ensures the response is returned in the same format as other clients.
   processResponse(obj, runner) {
     const ctx = obj.context;
-    const { response } = obj;
+    const { response, returning } = obj;
     if (obj.output) return obj.output.call(runner, response);
     switch (obj.method) {
       case 'select':
@@ -169,14 +171,26 @@ class Client_SQLite3 extends Client {
         return response[0];
       case 'pluck':
         return map(response, obj.pluck);
-      case 'insert':
+      case 'insert': {
+        if (returning) {
+          if (response) {
+            return response;
+          }
+
+          // ToDo Implement after https://github.com/microsoft/vscode-node-sqlite3/issues/15 is resolved
+          this.logger.warn(
+            'node-sqlite3 does not currently support RETURNING clause'
+          );
+        }
         return [ctx.lastID];
+      }
       case 'del':
       case 'update':
       case 'counter':
         return ctx.changes;
-      default:
+      default: {
         return response;
+      }
     }
   }
 

package/lib/dialects/sqlite3/query/sqlite-querycompiler.js

@@ -9,7 +9,10 @@ const reduce = require('lodash/reduce');
 const QueryCompiler = require('../../../query/querycompiler');
 const noop = require('../../../util/noop');
 const { isString } = require('../../../util/is');
-const { wrapString } = require('../../../formatter/wrappingFormatter');
+const {
+  wrapString,
+  columnize: columnize_,
+} = require('../../../formatter/wrappingFormatter');
 
 const emptyStr = constant('');
 
@@ -17,14 +20,6 @@ class QueryCompiler_SQLite3 extends QueryCompiler {
   constructor(client, builder, formatter) {
     super(client, builder, formatter);
 
-    const { returning } = this.single;
-
-    if (returning) {
-      this.client.logger.warn(
-        '.returning() is not supported by sqlite3 and will not have any effect.'
-      );
-    }
-
     // The locks are not applicable in SQLite3
     this.forShare = emptyStr;
     this.forKeyShare = emptyStr;
@@ -47,20 +42,28 @@ class QueryCompiler_SQLite3 extends QueryCompiler {
         insertValues[0] &&
         isEmpty(insertValues[0])
       ) {
-        return sql + this._emptyInsertValue;
+        return {
+          sql: sql + this._emptyInsertValue,
+        };
       }
     } else if (typeof insertValues === 'object' && isEmpty(insertValues)) {
-      return sql + this._emptyInsertValue;
+      return {
+        sql: sql + this._emptyInsertValue,
+      };
     }
 
     const insertData = this._prepInsert(insertValues);
 
     if (isString(insertData)) {
-      return sql + insertData;
+      return {
+        sql: sql + insertData,
+      };
     }
 
     if (insertData.columns.length === 0) {
-      return '';
+      return {
+        sql: '',
+      };
     }
 
     sql += `(${this.formatter.columnize(insertData.columns)})`;
@@ -96,7 +99,15 @@ class QueryCompiler_SQLite3 extends QueryCompiler {
         if (wheres) sql += ` ${wheres}`;
       }
 
-      return sql;
+      const { returning } = this.single;
+      if (returning) {
+        sql += this._returning(returning);
+      }
+
+      return {
+        sql,
+        returning,
+      };
     }
 
     const blocks = [];
@@ -129,7 +140,13 @@ class QueryCompiler_SQLite3 extends QueryCompiler {
         ' where true' + this._merge(merge.updates, onConflict, insertValues);
     }
 
-    return sql;
+    const { returning } = this.single;
+    if (returning) sql += this._returning(returning);
+
+    return {
+      sql,
+      returning,
+    };
   }
 
   _ignore(columns) {
@@ -185,6 +202,10 @@ class QueryCompiler_SQLite3 extends QueryCompiler {
     }
   }
 
+  _returning(value) {
+    return value ? ` returning ${this.formatter.columnize(value)}` : '';
+  }
+
   // Compile a truncate table statement into SQL.
   truncate() {
     const { table } = this.single;
@@ -241,11 +262,57 @@ class QueryCompiler_SQLite3 extends QueryCompiler {
 
     // Workaround for offset only,
     // see http://stackoverflow.com/questions/10491492/sqllite-with-skip-offset-only-not-limit
-    return `limit ${this.client.parameter(
-      noLimit ? -1 : this.single.limit,
+    this.single.limit = noLimit ? -1 : this.single.limit;
+    return `limit ${this._getValueOrParameterFromAttribute('limit')}`;
+  }
+
+  // Json functions
+  jsonExtract(params) {
+    return this._jsonExtract('json_extract', params);
+  }
+
+  jsonSet(params) {
+    return this._jsonSet('json_set', params);
+  }
+
+  jsonInsert(params) {
+    return this._jsonSet('json_insert', params);
+  }
+
+  jsonRemove(params) {
+    const jsonCol = `json_remove(${columnize_(
+      params.column,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )},${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_extract', statement);
+  }
+
+  whereJsonSupersetOf(statement) {
+    throw new Error(
+      'Json superset where clause not actually supported by SQLite'
+    );
+  }
+
+  whereJsonSubsetOf(statement) {
+    throw new Error(
+      'Json subset where clause not actually supported by SQLite'
+    );
+  }
+
+  onJsonPathEquals(clause) {
+    return this._onJsonPathEquals('json_extract', clause);
   }
 }