t/56-sqlite-producer.t

   1 #!/usr/bin/perl
   2 # vim: set ft=perl:
   3
   4 use strict;
   5 use Test::More;
   6 use Test::SQL::Translator qw(maybe_plan);
   7
   8 use SQL::Translator::Schema::View;
   9 use SQL::Translator::Schema::Table;
  10 use SQL::Translator::Producer::SQLite;
  11 $SQL::Translator::Producer::SQLite::NO_QUOTES = 0;
  12
  13 {
  14   my $view1 = SQL::Translator::Schema::View->new( name => 'view_foo',
  15                                                   fields => [qw/id name/],
  16                                                   sql => 'SELECT id, name FROM thing',
  17                                                   extra => {
  18                                                     temporary => 1,
  19                                                     if_not_exists => 1,
  20                                                   });
  21   my $create_opts = { no_comments => 1 };
  22   my $view1_sql1 = [ SQL::Translator::Producer::SQLite::create_view($view1, $create_opts) ];
  23
  24   my $view_sql_replace = [ 'CREATE TEMPORARY VIEW IF NOT EXISTS "view_foo" AS
  25     SELECT id, name FROM thing' ];
  26   is_deeply($view1_sql1, $view_sql_replace, 'correct "CREATE TEMPORARY VIEW" SQL');
  27
  28
  29   my $view2 = SQL::Translator::Schema::View->new( name => 'view_foo',
  30                                                   fields => [qw/id name/],
  31                                                   sql => 'SELECT id, name FROM thing',);
  32
  33   my $view1_sql2 = [ SQL::Translator::Producer::SQLite::create_view($view2, $create_opts) ];
  34   my $view_sql_noreplace = [ 'CREATE VIEW "view_foo" AS
  35     SELECT id, name FROM thing' ];
  36   is_deeply($view1_sql2, $view_sql_noreplace, 'correct "CREATE VIEW" SQL');
  37 }
  38 {
  39     my $create_opts;
  40
  41     my $table = SQL::Translator::Schema::Table->new(
  42         name => 'foo_table',
  43     );
  44     $table->add_field(
  45         name => 'foreign_key',
  46         data_type => 'integer',
  47         default_value => 1,
  48     );
  49     my $constraint = SQL::Translator::Schema::Constraint->new(
  50         table => $table,
  51         name => 'fk',
  52         type => 'FOREIGN_KEY',
  53         fields => ['foreign_key'],
  54         reference_fields => ['id'],
  55         reference_table => 'foo',
  56         on_delete => 'RESTRICT',
  57         on_update => 'CASCADE',
  58     );
  59     my $expected = [ 'FOREIGN KEY ("foreign_key") REFERENCES "foo"("id") ON DELETE RESTRICT ON UPDATE CASCADE'];
  60     my $result =  [SQL::Translator::Producer::SQLite::create_foreignkey($constraint,$create_opts)];
  61     is_deeply($result, $expected, 'correct "FOREIGN KEY"');
  62 }
  63 {
  64    my $table = SQL::Translator::Schema::Table->new(
  65        name => 'foo_table',
  66    );
  67    $table->add_field(
  68        name => 'id',
  69        data_type => 'integer',
  70        default_value => 1,
  71    );
  72    my $expected = [ qq<CREATE TABLE "foo_table" (\n  "id" integer DEFAULT 1\n)>];
  73    my $result =  [SQL::Translator::Producer::SQLite::create_table($table, { no_comments => 1 })];
  74    is_deeply($result, $expected, 'correctly unquoted DEFAULT');
  75 }
  76
  77 {
  78    my $table = SQL::Translator::Schema::Table->new(
  79        name => 'foo',
  80    );
  81    $table->add_field(
  82        name => 'data',
  83        data_type => 'bytea',
  84    );
  85    $table->add_field(
  86        name => 'data2',
  87        data_type => 'set',
  88    );
  89    $table->add_field(
  90        name => 'data2',
  91        data_type => 'set',
  92    );
  93    $table->add_field(
  94        name => 'data3',
  95        data_type => 'text',
  96        size      => 30,
  97    );
  98    $table->add_field(
  99        name => 'data4',
 100        data_type => 'blob',
 101        size      => 30,
 102    );
 103    my $expected = [ qq<CREATE TABLE "foo" (
 104   "data" blob,
 105   "data2" varchar,
 106   "data3" text,
 107   "data4" blob
 108 )>];
 109    my $result =  [SQL::Translator::Producer::SQLite::create_table($table, { no_comments => 1 })];
 110    is_deeply($result, $expected, 'correctly translated bytea to blob');
 111 }
 112
 113 {
 114    my $table = SQL::Translator::Schema::Table->new(
 115        name => 'foo_table',
 116    );
 117    $table->add_field(
 118        name => 'id',
 119        data_type => 'integer',
 120        default_value => \'gunshow',
 121    );
 122    my $expected = [ qq<CREATE TABLE "foo_table" (\n  "id" integer DEFAULT gunshow\n)>];
 123    my $result =  [SQL::Translator::Producer::SQLite::create_table($table, { no_comments => 1 })];
 124    is_deeply($result, $expected, 'correctly unquoted DEFAULT');
 125 }
 126
 127 {
 128    my $table = SQL::Translator::Schema::Table->new(
 129        name => 'foo_table',
 130    );
 131    $table->add_field(
 132        name => 'id',
 133        data_type => 'integer',
 134        default_value => 'frew',
 135    );
 136    my $expected = [ qq<CREATE TABLE "foo_table" (\n  "id" integer DEFAULT 'frew'\n)>];
 137    my $result =  [SQL::Translator::Producer::SQLite::create_table($table, { no_comments => 1 })];
 138    is_deeply($result, $expected, 'correctly quoted DEFAULT');
 139 }
 140
 141 {
 142    my $table = SQL::Translator::Schema::Table->new(
 143        name => 'foo',
 144    );
 145    $table->add_field(
 146        name => 'id',
 147        data_type => 'integer',
 148        default_value => 'NULL',
 149    );
 150    $table->add_field(
 151        name => 'when',
 152        default_value => 'now()',
 153    );
 154    $table->add_field(
 155        name => 'at',
 156        default_value => 'CURRENT_TIMESTAMP',
 157    );
 158    my $expected = [ qq<CREATE TABLE "foo" (
 159   "id" integer DEFAULT NULL,
 160   "when"  DEFAULT now(),
 161   "at"  DEFAULT CURRENT_TIMESTAMP
 162 )>];
 163    my $result =  [SQL::Translator::Producer::SQLite::create_table($table, { no_comments => 1 })];
 164    is_deeply($result, $expected, 'correctly unquoted excempted DEFAULTs');
 165 }
 166
 167 {
 168    my $table = SQL::Translator::Schema::Table->new(
 169        name => 'some_table',
 170    );
 171    $table->add_field(
 172        name => 'id',
 173        data_type => 'integer',
 174        is_auto_increment => 1,
 175        is_nullable => 0,
 176        extra => {
 177            auto_increment_type => 'monotonic',
 178        },
 179    );
 180    $table->primary_key('id');
 181    my $expected = [ qq<CREATE TABLE "some_table" (\n  "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL\n)>];
 182    my $result =  [SQL::Translator::Producer::SQLite::create_table($table, { no_comments => 1 })];
 183    is_deeply($result, $expected, 'correctly built monotonicly autoincremened PK');
 184 }
 185
 186 {
 187     my $table = SQL::Translator::Schema::Table->new( name => 'foobar', fields => ['foo'] );
 188
 189     {
 190         my $index = $table->add_index(name => 'myindex', fields => ['foo']);
 191         my ($def) = SQL::Translator::Producer::SQLite::create_index($index);
 192         is($def, 'CREATE INDEX "myindex" ON "foobar" ("foo")', 'index created');
 193     }
 194
 195     {
 196         my $index = $table->add_index(fields => ['foo']);
 197         my ($def) = SQL::Translator::Producer::SQLite::create_index($index);
 198         is($def, 'CREATE INDEX "foobar_idx" ON "foobar" ("foo")', 'index created');
 199     }
 200
 201     {
 202         my $constr = $table->add_constraint(name => 'constr', fields => ['foo']);
 203         my ($def) = SQL::Translator::Producer::SQLite::create_constraint($constr);
 204         is($def, 'CREATE UNIQUE INDEX "constr" ON "foobar" ("foo")', 'constraint created');
 205     }
 206
 207     {
 208         my $constr = $table->add_constraint(fields => ['foo']);
 209         my ($def) = SQL::Translator::Producer::SQLite::create_constraint($constr);
 210         is($def, 'CREATE UNIQUE INDEX "foobar_idx02" ON "foobar" ("foo")', 'constraint created');
 211     }
 212 }
 213
 214 done_testing;