mirror of
https://github.com/knex/knex.git
synced 2025-07-13 12:00:55 +00:00
808 lines
22 KiB
JavaScript
808 lines
22 KiB
JavaScript
/* eslint max-len:0 */
|
|
'use strict';
|
|
|
|
const { expect } = require('chai');
|
|
|
|
let tableSql;
|
|
|
|
const Redshift_Client = require('../../../lib/dialects/redshift');
|
|
const client = new Redshift_Client({ client: 'redshift' });
|
|
|
|
const equal = require('assert').equal;
|
|
|
|
describe('Redshift SchemaBuilder', function () {
|
|
it('fixes memoization regression', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.createTable('users', function (table) {
|
|
table.uuid('key');
|
|
table.increments('id');
|
|
table.string('email');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'create table "users" ("key" char(36), "id" integer identity(1,1) primary key not null, "email" varchar(255))'
|
|
);
|
|
});
|
|
|
|
it('create table like another', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.createTableLike('users_like', 'users')
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'create table "users_like" (like "users")'
|
|
);
|
|
});
|
|
|
|
it('basic alter table', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.increments('id');
|
|
table.string('email');
|
|
})
|
|
.toSQL();
|
|
equal(2, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "id" integer identity(1,1) primary key not null'
|
|
);
|
|
expect(tableSql[1].sql).to.equal(
|
|
'alter table "users" add column "email" varchar(255)'
|
|
);
|
|
});
|
|
|
|
it('alter table with schema', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.withSchema('myschema')
|
|
.table('users', function (table) {
|
|
table.increments('id');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "myschema"."users" add column "id" integer identity(1,1) primary key not null'
|
|
);
|
|
});
|
|
|
|
it('drop table', function () {
|
|
tableSql = client.schemaBuilder().dropTable('users').toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal('drop table "users"');
|
|
});
|
|
|
|
it('drop table with schema', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.withSchema('myschema')
|
|
.dropTable('users')
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal('drop table "myschema"."users"');
|
|
});
|
|
|
|
it('drop table if exists', function () {
|
|
tableSql = client.schemaBuilder().dropTableIfExists('users').toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal('drop table if exists "users"');
|
|
});
|
|
|
|
it('drop table if exists with schema', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.withSchema('myschema')
|
|
.dropTableIfExists('users')
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal('drop table if exists "myschema"."users"');
|
|
});
|
|
|
|
it('drop column', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dropColumn('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal('alter table "users" drop column "foo"');
|
|
});
|
|
|
|
it('drop multiple columns', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dropColumn(['foo', 'bar']);
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" drop column "foo", drop column "bar"'
|
|
);
|
|
});
|
|
|
|
it('drop multiple columns with arguments', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dropColumn('foo', 'bar');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" drop column "foo", drop column "bar"'
|
|
);
|
|
});
|
|
|
|
it('drop primary', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dropPrimary();
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" drop constraint "users_pkey"'
|
|
);
|
|
});
|
|
|
|
it('drop unique', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dropUnique('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" drop constraint "users_foo_unique"'
|
|
);
|
|
});
|
|
|
|
it('drop unique, custom', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dropUnique(null, 'foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" drop constraint "foo"'
|
|
);
|
|
});
|
|
|
|
it('drop index should be a no-op', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dropIndex('foo');
|
|
})
|
|
.toSQL();
|
|
equal(0, tableSql.length);
|
|
});
|
|
|
|
it('drop foreign', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dropForeign('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" drop constraint "users_foo_foreign"'
|
|
);
|
|
});
|
|
|
|
it('drop foreign', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dropForeign(null, 'foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" drop constraint "foo"'
|
|
);
|
|
});
|
|
|
|
it('drop timestamps', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dropTimestamps();
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" drop column "created_at", drop column "updated_at"'
|
|
);
|
|
});
|
|
|
|
it('rename table', function () {
|
|
tableSql = client.schemaBuilder().renameTable('users', 'foo').toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal('alter table "users" rename to "foo"');
|
|
});
|
|
|
|
it('adding primary key', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.primary('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add constraint "users_pkey" primary key ("foo")'
|
|
);
|
|
});
|
|
|
|
it('adding primary key fluently', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.createTable('users', function (table) {
|
|
table.string('name').primary();
|
|
table.string('foo');
|
|
})
|
|
.toSQL();
|
|
equal(2, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'create table "users" ("name" varchar(255) not null, "foo" varchar(255))'
|
|
);
|
|
expect(tableSql[1].sql).to.equal(
|
|
'alter table "users" add constraint "users_pkey" primary key ("name")'
|
|
);
|
|
});
|
|
|
|
it('adding foreign key', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.createTable('accounts', function (table) {
|
|
table.integer('account_id').references('users.id');
|
|
})
|
|
.toSQL();
|
|
expect(tableSql[1].sql).to.equal(
|
|
'alter table "accounts" add constraint "accounts_account_id_foreign" foreign key ("account_id") references "users" ("id")'
|
|
);
|
|
});
|
|
|
|
it('adds foreign key with onUpdate and onDelete', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.createTable('person', function (table) {
|
|
table
|
|
.integer('user_id')
|
|
.notNull()
|
|
.references('users.id')
|
|
.onDelete('SET NULL');
|
|
table
|
|
.integer('account_id')
|
|
.notNull()
|
|
.references('id')
|
|
.inTable('accounts')
|
|
.onUpdate('cascade');
|
|
})
|
|
.toSQL();
|
|
equal(3, tableSql.length);
|
|
expect(tableSql[1].sql).to.equal(
|
|
'alter table "person" add constraint "person_user_id_foreign" foreign key ("user_id") references "users" ("id") on delete SET NULL'
|
|
);
|
|
expect(tableSql[2].sql).to.equal(
|
|
'alter table "person" add constraint "person_account_id_foreign" foreign key ("account_id") references "accounts" ("id") on update cascade'
|
|
);
|
|
});
|
|
|
|
it('adding unique key', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.unique('foo', 'bar');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add constraint "bar" unique ("foo")'
|
|
);
|
|
});
|
|
|
|
it('adding unique key fluently', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.createTable('users', function (table) {
|
|
table.string('email').unique();
|
|
})
|
|
.toSQL();
|
|
equal(2, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'create table "users" ("email" varchar(255))'
|
|
);
|
|
expect(tableSql[1].sql).to.equal(
|
|
'alter table "users" add constraint "users_email_unique" unique ("email")'
|
|
);
|
|
});
|
|
|
|
it('adding index should be a no-op', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.index(['foo', 'bar'], 'baz');
|
|
})
|
|
.toSQL();
|
|
equal(0, tableSql.length);
|
|
});
|
|
|
|
it('adding incrementing id', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.increments('id');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "id" integer identity(1,1) primary key not null'
|
|
);
|
|
});
|
|
|
|
it('adding big incrementing id', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.bigIncrements('id');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "id" bigint identity(1,1) primary key not null'
|
|
);
|
|
});
|
|
|
|
it('adding string', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.string('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" varchar(255)'
|
|
);
|
|
});
|
|
|
|
it('adding varchar with length', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.string('foo', 100);
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" varchar(100)'
|
|
);
|
|
});
|
|
|
|
it('adding a string with a default', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.string('foo', 100).defaultTo('bar');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" varchar(100) default \'bar\''
|
|
);
|
|
});
|
|
|
|
it('adding text', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.text('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" varchar(max)'
|
|
);
|
|
});
|
|
|
|
it('adding big integer', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.bigInteger('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" bigint'
|
|
);
|
|
});
|
|
|
|
it('tests a big integer as the primary autoincrement key', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.bigIncrements('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" bigint identity(1,1) primary key not null'
|
|
);
|
|
});
|
|
|
|
it('adding integer', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.integer('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" integer'
|
|
);
|
|
});
|
|
|
|
it('adding autoincrement integer', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.increments('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" integer identity(1,1) primary key not null'
|
|
);
|
|
});
|
|
|
|
it('adding medium integer', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.mediumint('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" integer'
|
|
);
|
|
});
|
|
|
|
it('adding tiny integer', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.tinyint('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" smallint'
|
|
);
|
|
});
|
|
|
|
it('adding small integer', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.smallint('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" smallint'
|
|
);
|
|
});
|
|
|
|
it('adding float', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.float('foo', 5, 2);
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" real'
|
|
);
|
|
});
|
|
|
|
it('adding double', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.double('foo', 15, 8);
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" double precision'
|
|
);
|
|
});
|
|
|
|
it('adding decimal', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.decimal('foo', 5, 2);
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" decimal(5, 2)'
|
|
);
|
|
});
|
|
|
|
it('adding boolean', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.boolean('foo').defaultTo(false);
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" boolean default \'0\''
|
|
);
|
|
});
|
|
|
|
it('adding enum', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.enum('foo', ['bar', 'baz']);
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" varchar(255)'
|
|
);
|
|
});
|
|
|
|
it('adding date', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.date('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" date'
|
|
);
|
|
});
|
|
|
|
it('adding date time', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.dateTime('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" timestamptz'
|
|
);
|
|
});
|
|
|
|
it('adding time', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.time('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" time'
|
|
);
|
|
});
|
|
|
|
it('adding timestamp', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.timestamp('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" timestamptz'
|
|
);
|
|
});
|
|
|
|
it('adding timestamps', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.timestamps();
|
|
})
|
|
.toSQL();
|
|
equal(2, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "created_at" timestamptz'
|
|
);
|
|
expect(tableSql[1].sql).to.equal(
|
|
'alter table "users" add column "updated_at" timestamptz'
|
|
);
|
|
});
|
|
|
|
it('adding timestamps with defaults', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.timestamps(false, true);
|
|
})
|
|
.toSQL();
|
|
equal(2, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "created_at" timestamptz not null default CURRENT_TIMESTAMP'
|
|
);
|
|
expect(tableSql[1].sql).to.equal(
|
|
'alter table "users" add column "updated_at" timestamptz not null default CURRENT_TIMESTAMP'
|
|
);
|
|
});
|
|
|
|
it('adding binary', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (table) {
|
|
table.binary('foo');
|
|
})
|
|
.toSQL();
|
|
equal(1, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "foo" varchar(max)'
|
|
);
|
|
});
|
|
|
|
it('adding jsonb', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('user', function (t) {
|
|
t.jsonb('preferences');
|
|
})
|
|
.toSQL();
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "user" add column "preferences" varchar(max)'
|
|
);
|
|
});
|
|
|
|
it('allows adding default json objects when the column is json', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('user', function (t) {
|
|
t.json('preferences').defaultTo({}).notNullable();
|
|
})
|
|
.toSQL();
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "user" add column "preferences" varchar(max) not null default \'{}\''
|
|
);
|
|
});
|
|
|
|
it('sets specificType correctly', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('user', function (t) {
|
|
t.specificType('email', 'CITEXT').unique().notNullable();
|
|
})
|
|
.toSQL();
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "user" add column "email" CITEXT not null'
|
|
);
|
|
});
|
|
|
|
it('allows creating an extension', function () {
|
|
const sql = client.schemaBuilder().createExtension('test').toSQL();
|
|
expect(sql[0].sql).to.equal('create extension "test"');
|
|
});
|
|
|
|
it('allows dropping an extension', function () {
|
|
const sql = client.schemaBuilder().dropExtension('test').toSQL();
|
|
expect(sql[0].sql).to.equal('drop extension "test"');
|
|
});
|
|
|
|
it("allows creating an extension only if it doesn't exist", function () {
|
|
const sql = client
|
|
.schemaBuilder()
|
|
.createExtensionIfNotExists('test')
|
|
.toSQL();
|
|
expect(sql[0].sql).to.equal('create extension if not exists "test"');
|
|
});
|
|
|
|
it('allows dropping an extension only if it exists', function () {
|
|
const sql = client.schemaBuilder().dropExtensionIfExists('test').toSQL();
|
|
expect(sql[0].sql).to.equal('drop extension if exists "test"');
|
|
});
|
|
|
|
it('does not support table inheritance', function () {
|
|
expect(() => {
|
|
client
|
|
.schemaBuilder()
|
|
.createTable('inheriteeTable', function (t) {
|
|
t.string('username');
|
|
t.inherits('inheritedTable');
|
|
})
|
|
.toSQL();
|
|
}).to.throw('Knex only supports inherits statement with postgresql');
|
|
});
|
|
|
|
it('should throw on usage of disallowed method', function () {
|
|
expect(() => {
|
|
client
|
|
.schemaBuilder()
|
|
.createTable('users', function (t) {
|
|
t.string('username');
|
|
t.engine('myISAM');
|
|
})
|
|
.toSQL();
|
|
}).to.throw('Knex only supports engine statement with mysql');
|
|
});
|
|
|
|
it('#1430 - .primary & .dropPrimary takes columns and constraintName', function () {
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (t) {
|
|
// t.string('test1').notNullable();
|
|
t.string('test1');
|
|
t.string('test2').notNullable();
|
|
t.primary(['test1', 'test2'], 'testconstraintname');
|
|
})
|
|
.toSQL();
|
|
|
|
equal(2, tableSql.length);
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "test1" varchar(255)'
|
|
);
|
|
expect(tableSql[1].sql).to.equal(
|
|
'alter table "users" add column "test2" varchar(255) not null'
|
|
);
|
|
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.table('users', function (t) {
|
|
t.string('test1').notNullable();
|
|
t.string('test2').notNullable();
|
|
t.primary(['test1', 'test2'], 'testconstraintname');
|
|
})
|
|
.toSQL();
|
|
|
|
expect(tableSql[0].sql).to.equal(
|
|
'alter table "users" add column "test1" varchar(255) not null'
|
|
);
|
|
expect(tableSql[1].sql).to.equal(
|
|
'alter table "users" add column "test2" varchar(255) not null'
|
|
);
|
|
expect(tableSql[2].sql).to.equal(
|
|
'alter table "users" add constraint "testconstraintname" primary key ("test1", "test2")'
|
|
);
|
|
|
|
tableSql = client
|
|
.schemaBuilder()
|
|
.createTable('users', function (t) {
|
|
t.string('test').primary('testconstraintname');
|
|
})
|
|
.toSQL();
|
|
|
|
expect(tableSql[0].sql).to.equal(
|
|
'create table "users" ("test" varchar(255) not null)'
|
|
);
|
|
expect(tableSql[1].sql).to.equal(
|
|
'alter table "users" add constraint "testconstraintname" primary key ("test")'
|
|
);
|
|
});
|
|
});
|