test/without_rowid3.test

   1 # 2013-11-02
   2 #
   3 # The author disclaims copyright to this source code.  In place of
   4 # a legal notice, here is a blessing:
   5 #
   6 #    May you do good and not evil.
   7 #    May you find forgiveness for yourself and forgive others.
   8 #    May you share freely, never taking more than you give.
   9 #
  10 #***********************************************************************
  11 # This file implements regression tests for SQLite library.
  12 #
  13 # This file implements tests for foreign keys on WITHOUT ROWID
  14 # tables.
  15 #
  16
  17 set testdir [file dirname $argv0]
  18 source $testdir/tester.tcl
  19
  20 ifcapable {!foreignkey||!trigger} {
  21   finish_test
  22   return
  23 }
  24
  25 #-------------------------------------------------------------------------
  26 # Test structure:
  27 #
  28 # without_rowid3-1.*: Simple tests to check that immediate and deferred foreign key
  29 #            constraints work when not inside a transaction.
  30 #
  31 # without_rowid3-2.*: Tests to verify that deferred foreign keys work inside
  32 #            explicit transactions (i.e that processing really is deferred).
  33 #
  34 # without_rowid3-3.*: Tests that a statement transaction is rolled back if an
  35 #            immediate foreign key constraint is violated.
  36 #
  37 # without_rowid3-4.*: Test that FK actions may recurse even when recursive triggers
  38 #            are disabled.
  39 #
  40 # without_rowid3-5.*: Check that if foreign-keys are enabled, it is not possible
  41 #            to write to an FK column using the incremental blob API.
  42 #
  43 # without_rowid3-6.*: Test that FK processing is automatically disabled when
  44 #            running VACUUM.
  45 #
  46 # without_rowid3-7.*: Test using an IPK as the key in the child (referencing) table.
  47 #
  48 # without_rowid3-8.*: Test that enabling/disabling foreign key support while a
  49 #            transaction is active is not possible.
  50 #
  51 # without_rowid3-9.*: Test SET DEFAULT actions.
  52 #
  53 # without_rowid3-10.*: Test errors.
  54 #
  55 # without_rowid3-11.*: Test CASCADE actions.
  56 #
  57 # without_rowid3-12.*: Test RESTRICT actions.
  58 #
  59 # without_rowid3-13.*: Test that FK processing is performed when a row is REPLACED by
  60 #             an UPDATE or INSERT statement.
  61 #
  62 # without_rowid3-14.*: Test the ALTER TABLE and DROP TABLE commands.
  63 #
  64 # without_rowid3-15.*: Test that if there are no (known) outstanding foreign key
  65 #             constraint violations in the database, inserting into a parent
  66 #             table or deleting from a child table does not cause SQLite
  67 #             to check if this has repaired an outstanding violation.
  68 #
  69 # without_rowid3-16.*: Test that rows that refer to themselves may be inserted,
  70 #             updated and deleted.
  71 #
  72 # without_rowid3-17.*: Test that the "count_changes" pragma does not interfere with
  73 #             FK constraint processing.
  74 #
  75 # without_rowid3-18.*: Test that the authorization callback is invoked when processing
  76 #             FK constraints.
  77 #
  78 # without_rowid3-20.*: Test that ON CONFLICT clauses specified as part of statements
  79 #             do not affect the operation of FK constraints.
  80 #
  81 # without_rowid3-genfkey.*: Tests that were used with the shell tool .genfkey
  82 #            command. Recycled to test the built-in implementation.
  83 #
  84 # without_rowid3-dd08e5.*:  Tests to verify that ticket dd08e5a988d00decc4a543daa8d
  85 #                  has been fixed.
  86 #
  87
  88
  89 execsql { PRAGMA foreign_keys = on }
  90
  91 set FkeySimpleSchema {
  92   PRAGMA foreign_keys = on;
  93   CREATE TABLE t1(a PRIMARY KEY, b) WITHOUT rowid;
  94   CREATE TABLE t2(c REFERENCES t1(a) /D/ , d);
  95
  96   CREATE TABLE t3(a PRIMARY KEY, b) WITHOUT rowid;
  97   CREATE TABLE t4(c REFERENCES t3 /D/, d);
  98
  99   CREATE TABLE t7(a, b INT PRIMARY KEY) WITHOUT rowid;
 100   CREATE TABLE t8(c REFERENCES t7 /D/, d);
 101
 102   CREATE TABLE t9(a REFERENCES nosuchtable, b);
 103   CREATE TABLE t10(a REFERENCES t9(c) /D/, b);
 104 }
 105
 106
 107 set FkeySimpleTests {
 108   1.1  "INSERT INTO t2 VALUES(1, 3)"      {1 {FOREIGN KEY constraint failed}}
 109   1.2  "INSERT INTO t1 VALUES(1, 2)"      {0 {}}
 110   1.3  "INSERT INTO t2 VALUES(1, 3)"      {0 {}}
 111   1.4  "INSERT INTO t2 VALUES(2, 4)"      {1 {FOREIGN KEY constraint failed}}
 112   1.5  "INSERT INTO t2 VALUES(NULL, 4)"   {0 {}}
 113   1.6  "UPDATE t2 SET c=2 WHERE d=4"      {1 {FOREIGN KEY constraint failed}}
 114   1.7  "UPDATE t2 SET c=1 WHERE d=4"      {0 {}}
 115   1.9  "UPDATE t2 SET c=1 WHERE d=4"      {0 {}}
 116   1.10 "UPDATE t2 SET c=NULL WHERE d=4"   {0 {}}
 117   1.11 "DELETE FROM t1 WHERE a=1"         {1 {FOREIGN KEY constraint failed}}
 118   1.12 "UPDATE t1 SET a = 2"              {1 {FOREIGN KEY constraint failed}}
 119   1.13 "UPDATE t1 SET a = 1"              {0 {}}
 120
 121   2.1  "INSERT INTO t4 VALUES(1, 3)"      {1 {FOREIGN KEY constraint failed}}
 122   2.2  "INSERT INTO t3 VALUES(1, 2)"      {0 {}}
 123   2.3  "INSERT INTO t4 VALUES(1, 3)"      {0 {}}
 124
 125   4.1  "INSERT INTO t8 VALUES(1, 3)"      {1 {FOREIGN KEY constraint failed}}
 126   4.2  "INSERT INTO t7 VALUES(2, 1)"      {0 {}}
 127   4.3  "INSERT INTO t8 VALUES(1, 3)"      {0 {}}
 128   4.4  "INSERT INTO t8 VALUES(2, 4)"      {1 {FOREIGN KEY constraint failed}}
 129   4.5  "INSERT INTO t8 VALUES(NULL, 4)"   {0 {}}
 130   4.6  "UPDATE t8 SET c=2 WHERE d=4"      {1 {FOREIGN KEY constraint failed}}
 131   4.7  "UPDATE t8 SET c=1 WHERE d=4"      {0 {}}
 132   4.9  "UPDATE t8 SET c=1 WHERE d=4"      {0 {}}
 133   4.10 "UPDATE t8 SET c=NULL WHERE d=4"   {0 {}}
 134   4.11 "DELETE FROM t7 WHERE b=1"         {1 {FOREIGN KEY constraint failed}}
 135   4.12 "UPDATE t7 SET b = 2"              {1 {FOREIGN KEY constraint failed}}
 136   4.13 "UPDATE t7 SET b = 1"              {0 {}}
 137   4.14 "INSERT INTO t8 VALUES('a', 'b')"  {1 {FOREIGN KEY constraint failed}}
 138   4.15 "UPDATE t7 SET b = 5"              {1 {FOREIGN KEY constraint failed}}
 139   4.17 "UPDATE t7 SET a = 10"             {0 {}}
 140
 141   5.1  "INSERT INTO t9 VALUES(1, 3)"      {1 {no such table: main.nosuchtable}}
 142   5.2  "INSERT INTO t10 VALUES(1, 3)"
 143                             {1 {foreign key mismatch - "t10" referencing "t9"}}
 144 }
 145
 146 do_test without_rowid3-1.1.0 {
 147   execsql [string map {/D/ {}} $FkeySimpleSchema]
 148 } {}
 149 foreach {tn zSql res} $FkeySimpleTests {
 150   do_test without_rowid3-1.1.$tn.1 { catchsql $zSql } $res
 151   do_test without_rowid3-1.1.$tn.2 { execsql {PRAGMA foreign_key_check(t1)} } {}
 152   do_test without_rowid3-1.1.$tn.3 { execsql {PRAGMA foreign_key_check(t2)} } {}
 153   do_test without_rowid3-1.1.$tn.4 { execsql {PRAGMA foreign_key_check(t3)} } {}
 154   do_test without_rowid3-1.1.$tn.5 { execsql {PRAGMA foreign_key_check(t4)} } {}
 155   do_test without_rowid3-1.1.$tn.6 { execsql {PRAGMA foreign_key_check(t7)} } {}
 156   do_test without_rowid3-1.1.$tn.7 { execsql {PRAGMA foreign_key_check(t8)} } {}
 157 }
 158 drop_all_tables
 159
 160 do_test without_rowid3-1.2.0 {
 161   execsql [string map {/D/ {DEFERRABLE INITIALLY DEFERRED}} $FkeySimpleSchema]
 162 } {}
 163 foreach {tn zSql res} $FkeySimpleTests {
 164   do_test without_rowid3-1.2.$tn { catchsql $zSql } $res
 165   do_test without_rowid3-1.2.$tn.2 { execsql {PRAGMA foreign_key_check(t1)} } {}
 166   do_test without_rowid3-1.2.$tn.3 { execsql {PRAGMA foreign_key_check(t2)} } {}
 167   do_test without_rowid3-1.2.$tn.4 { execsql {PRAGMA foreign_key_check(t3)} } {}
 168   do_test without_rowid3-1.2.$tn.5 { execsql {PRAGMA foreign_key_check(t4)} } {}
 169   do_test without_rowid3-1.2.$tn.6 { execsql {PRAGMA foreign_key_check(t7)} } {}
 170   do_test without_rowid3-1.2.$tn.7 { execsql {PRAGMA foreign_key_check(t8)} } {}
 171 }
 172 drop_all_tables
 173
 174 do_test without_rowid3-1.3.0 {
 175   execsql [string map {/D/ {}} $FkeySimpleSchema]
 176   execsql { PRAGMA count_changes = 1 }
 177 } {}
 178 foreach {tn zSql res} $FkeySimpleTests {
 179   if {$res == "0 {}"} { set res {0 1} }
 180   do_test without_rowid3-1.3.$tn { catchsql $zSql } $res
 181   do_test without_rowid3-1.3.$tn.2 { execsql {PRAGMA foreign_key_check(t1)} } {}
 182   do_test without_rowid3-1.3.$tn.3 { execsql {PRAGMA foreign_key_check(t2)} } {}
 183   do_test without_rowid3-1.3.$tn.4 { execsql {PRAGMA foreign_key_check(t3)} } {}
 184   do_test without_rowid3-1.3.$tn.5 { execsql {PRAGMA foreign_key_check(t4)} } {}
 185   do_test without_rowid3-1.3.$tn.6 { execsql {PRAGMA foreign_key_check(t7)} } {}
 186   do_test without_rowid3-1.3.$tn.7 { execsql {PRAGMA foreign_key_check(t8)} } {}
 187 }
 188 execsql { PRAGMA count_changes = 0 }
 189 drop_all_tables
 190
 191 do_test without_rowid3-1.4.0 {
 192   execsql [string map {/D/ {}} $FkeySimpleSchema]
 193   execsql { PRAGMA count_changes = 1 }
 194 } {}
 195 foreach {tn zSql res} $FkeySimpleTests {
 196   if {$res == "0 {}"} { set res {0 1} }
 197   execsql BEGIN
 198   do_test without_rowid3-1.4.$tn { catchsql $zSql } $res
 199   execsql COMMIT
 200 }
 201 execsql { PRAGMA count_changes = 0 }
 202 drop_all_tables
 203
 204 # Special test: When the parent key is an IPK, make sure the affinity of
 205 # the IPK is not applied to the child key value before it is inserted
 206 # into the child table.
 207 do_test without_rowid3-1.5.1 {
 208   execsql {
 209     CREATE TABLE i(i INT PRIMARY KEY) WITHOUT rowid;
 210     CREATE TABLE j(j REFERENCES i);
 211     INSERT INTO i VALUES(35);
 212     INSERT INTO j VALUES('35.0');
 213     SELECT j, typeof(j) FROM j;
 214   }
 215 } {35.0 text}
 216 do_test without_rowid3-1.5.2 {
 217   catchsql { DELETE FROM i }
 218 } {1 {FOREIGN KEY constraint failed}}
 219
 220 # Same test using a regular primary key with integer affinity.
 221 drop_all_tables
 222 do_test without_rowid3-1.6.1 {
 223   execsql {
 224     CREATE TABLE i(i INT UNIQUE);
 225     CREATE TABLE j(j REFERENCES i(i));
 226     INSERT INTO i VALUES('35.0');
 227     INSERT INTO j VALUES('35.0');
 228     SELECT j, typeof(j) FROM j;
 229     SELECT i, typeof(i) FROM i;
 230   }
 231 } {35.0 text 35 integer}
 232 do_test without_rowid3-1.6.2 {
 233   catchsql { DELETE FROM i }
 234 } {1 {FOREIGN KEY constraint failed}}
 235
 236 # Use a collation sequence on the parent key.
 237 drop_all_tables
 238 do_test without_rowid3-1.7.1 {
 239   execsql {
 240     CREATE TABLE i(i TEXT COLLATE nocase PRIMARY KEY) WITHOUT rowid;
 241     CREATE TABLE j(j TEXT COLLATE binary REFERENCES i(i));
 242     INSERT INTO i VALUES('SQLite');
 243     INSERT INTO j VALUES('sqlite');
 244   }
 245   catchsql { DELETE FROM i }
 246 } {1 {FOREIGN KEY constraint failed}}
 247
 248 # Use the parent key collation even if it is default and the child key
 249 # has an explicit value.
 250 drop_all_tables
 251 do_test without_rowid3-1.7.2 {
 252   execsql {
 253     CREATE TABLE i(i TEXT PRIMARY KEY) WITHOUT rowid;  -- Colseq is "BINARY"
 254     CREATE TABLE j(j TEXT COLLATE nocase REFERENCES i(i));
 255     INSERT INTO i VALUES('SQLite');
 256   }
 257   catchsql { INSERT INTO j VALUES('sqlite') }
 258 } {1 {FOREIGN KEY constraint failed}}
 259 do_test without_rowid3-1.7.3 {
 260   execsql {
 261     INSERT INTO i VALUES('sqlite');
 262     INSERT INTO j VALUES('sqlite');
 263     DELETE FROM i WHERE i = 'SQLite';
 264   }
 265   catchsql { DELETE FROM i WHERE i = 'sqlite' }
 266 } {1 {FOREIGN KEY constraint failed}}
 267
 268 #-------------------------------------------------------------------------
 269 # This section (test cases without_rowid3-2.*) contains tests to check that the
 270 # deferred foreign key constraint logic works.
 271 #
 272 proc without_rowid3-2-test {tn nocommit sql {res {}}} {
 273   if {$res eq "FKV"} {
 274     set expected {1 {FOREIGN KEY constraint failed}}
 275   } else {
 276     set expected [list 0 $res]
 277   }
 278   do_test without_rowid3-2.$tn [list catchsql $sql] $expected
 279   if {$nocommit} {
 280     do_test without_rowid3-2.${tn}c {
 281       catchsql COMMIT
 282     } {1 {FOREIGN KEY constraint failed}}
 283   }
 284 }
 285
 286 without_rowid3-2-test 1 0 {
 287   CREATE TABLE node(
 288     nodeid PRIMARY KEY,
 289     parent REFERENCES node DEFERRABLE INITIALLY DEFERRED
 290   ) WITHOUT rowid;
 291   CREATE TABLE leaf(
 292     cellid PRIMARY KEY,
 293     parent REFERENCES node DEFERRABLE INITIALLY DEFERRED
 294   ) WITHOUT rowid;
 295 }
 296
 297 without_rowid3-2-test 1  0 "INSERT INTO node VALUES(1, 0)"       FKV
 298 without_rowid3-2-test 2  0 "BEGIN"
 299 without_rowid3-2-test 3  1   "INSERT INTO node VALUES(1, 0)"
 300 without_rowid3-2-test 4  0   "UPDATE node SET parent = NULL"
 301 without_rowid3-2-test 5  0 "COMMIT"
 302 without_rowid3-2-test 6  0 "SELECT * FROM node" {1 {}}
 303
 304 without_rowid3-2-test 7  0 "BEGIN"
 305 without_rowid3-2-test 8  1   "INSERT INTO leaf VALUES('a', 2)"
 306 without_rowid3-2-test 9  1   "INSERT INTO node VALUES(2, 0)"
 307 without_rowid3-2-test 10 0   "UPDATE node SET parent = 1 WHERE nodeid = 2"
 308 without_rowid3-2-test 11 0 "COMMIT"
 309 without_rowid3-2-test 12 0 "SELECT * FROM node" {1 {} 2 1}
 310 without_rowid3-2-test 13 0 "SELECT * FROM leaf" {a 2}
 311
 312 without_rowid3-2-test 14 0 "BEGIN"
 313 without_rowid3-2-test 15 1   "DELETE FROM node WHERE nodeid = 2"
 314 without_rowid3-2-test 16 0   "INSERT INTO node VALUES(2, NULL)"
 315 without_rowid3-2-test 17 0 "COMMIT"
 316 without_rowid3-2-test 18 0 "SELECT * FROM node" {1 {} 2 {}}
 317 without_rowid3-2-test 19 0 "SELECT * FROM leaf" {a 2}
 318
 319 without_rowid3-2-test 20 0 "BEGIN"
 320 without_rowid3-2-test 21 0   "INSERT INTO leaf VALUES('b', 1)"
 321 without_rowid3-2-test 22 0   "SAVEPOINT save"
 322 without_rowid3-2-test 23 0     "DELETE FROM node WHERE nodeid = 1"
 323 without_rowid3-2-test 24 0   "ROLLBACK TO save"
 324 without_rowid3-2-test 25 0 "COMMIT"
 325 without_rowid3-2-test 26 0 "SELECT * FROM node" {1 {} 2 {}}
 326 without_rowid3-2-test 27 0 "SELECT * FROM leaf" {a 2 b 1}
 327
 328 without_rowid3-2-test 28 0 "BEGIN"
 329 without_rowid3-2-test 29 0   "INSERT INTO leaf VALUES('c', 1)"
 330 without_rowid3-2-test 30 0   "SAVEPOINT save"
 331 without_rowid3-2-test 31 0     "DELETE FROM node WHERE nodeid = 1"
 332 without_rowid3-2-test 32 1   "RELEASE save"
 333 without_rowid3-2-test 33 1   "DELETE FROM leaf WHERE cellid = 'b'"
 334 without_rowid3-2-test 34 0   "DELETE FROM leaf WHERE cellid = 'c'"
 335 without_rowid3-2-test 35 0 "COMMIT"
 336 without_rowid3-2-test 36 0 "SELECT * FROM node" {2 {}}
 337 without_rowid3-2-test 37 0 "SELECT * FROM leaf" {a 2}
 338
 339 without_rowid3-2-test 38 0 "SAVEPOINT outer"
 340 without_rowid3-2-test 39 1   "INSERT INTO leaf VALUES('d', 3)"
 341 without_rowid3-2-test 40 1 "RELEASE outer"    FKV
 342 without_rowid3-2-test 41 1   "INSERT INTO leaf VALUES('e', 3)"
 343 without_rowid3-2-test 42 0   "INSERT INTO node VALUES(3, 2)"
 344 without_rowid3-2-test 43 0 "RELEASE outer"
 345
 346 without_rowid3-2-test 44 0 "SAVEPOINT outer"
 347 without_rowid3-2-test 45 1   "DELETE FROM node WHERE nodeid=3"
 348 without_rowid3-2-test 47 0   "INSERT INTO node VALUES(3, 2)"
 349 without_rowid3-2-test 48 0 "ROLLBACK TO outer"
 350 without_rowid3-2-test 49 0 "RELEASE outer"
 351
 352 without_rowid3-2-test 50 0 "SAVEPOINT outer"
 353 without_rowid3-2-test 51 1   "INSERT INTO leaf VALUES('f', 4)"
 354 without_rowid3-2-test 52 1   "SAVEPOINT inner"
 355 without_rowid3-2-test 53 1     "INSERT INTO leaf VALUES('g', 4)"
 356 without_rowid3-2-test 54 1  "RELEASE outer"   FKV
 357 without_rowid3-2-test 55 1   "ROLLBACK TO inner"
 358 without_rowid3-2-test 56 0  "COMMIT"          FKV
 359 without_rowid3-2-test 57 0   "INSERT INTO node VALUES(4, NULL)"
 360 without_rowid3-2-test 58 0 "RELEASE outer"
 361 without_rowid3-2-test 59 0 "SELECT * FROM node" {2 {} 3 2 4 {}}
 362 without_rowid3-2-test 60 0 "SELECT * FROM leaf" {a 2 d 3 e 3 f 4}
 363
 364 # The following set of tests check that if a statement that affects
 365 # multiple rows violates some foreign key constraints, then strikes a
 366 # constraint that causes the statement-transaction to be rolled back,
 367 # the deferred constraint counter is correctly reset to the value it
 368 # had before the statement-transaction was opened.
 369 #
 370 without_rowid3-2-test 61 0 "BEGIN"
 371 without_rowid3-2-test 62 0   "DELETE FROM leaf"
 372 without_rowid3-2-test 63 0   "DELETE FROM node"
 373 without_rowid3-2-test 64 1   "INSERT INTO leaf VALUES('a', 1)"
 374 without_rowid3-2-test 65 1   "INSERT INTO leaf VALUES('b', 2)"
 375 without_rowid3-2-test 66 1   "INSERT INTO leaf VALUES('c', 1)"
 376 do_test without_rowid3-2-test-67 {
 377   catchsql          "INSERT INTO node SELECT parent, 3 FROM leaf"
 378 } {1 {UNIQUE constraint failed: node.nodeid}}
 379 without_rowid3-2-test 68 0 "COMMIT"           FKV
 380 without_rowid3-2-test 69 1   "INSERT INTO node VALUES(1, NULL)"
 381 without_rowid3-2-test 70 0   "INSERT INTO node VALUES(2, NULL)"
 382 without_rowid3-2-test 71 0 "COMMIT"
 383
 384 without_rowid3-2-test 72 0 "BEGIN"
 385 without_rowid3-2-test 73 1   "DELETE FROM node"
 386 without_rowid3-2-test 74 0   "INSERT INTO node(nodeid) SELECT DISTINCT parent FROM leaf"
 387 without_rowid3-2-test 75 0 "COMMIT"
 388
 389 #-------------------------------------------------------------------------
 390 # Test cases without_rowid3-3.* test that a program that executes foreign key
 391 # actions (CASCADE, SET DEFAULT, SET NULL etc.) or tests FK constraints
 392 # opens a statement transaction if required.
 393 #
 394 # without_rowid3-3.1.*: Test UPDATE statements.
 395 # without_rowid3-3.2.*: Test DELETE statements.
 396 #
 397 drop_all_tables
 398 do_test without_rowid3-3.1.1 {
 399   execsql {
 400     CREATE TABLE ab(a PRIMARY KEY, b) WITHOUT rowid;
 401     CREATE TABLE cd(
 402       c PRIMARY KEY REFERENCES ab ON UPDATE CASCADE ON DELETE CASCADE,
 403       d
 404     ) WITHOUT rowid;
 405     CREATE TABLE ef(
 406       e REFERENCES cd ON UPDATE CASCADE,
 407       f, CHECK (e!=5)
 408     );
 409   }
 410 } {}
 411 do_test without_rowid3-3.1.2 {
 412   execsql {
 413     INSERT INTO ab VALUES(1, 'b');
 414     INSERT INTO cd VALUES(1, 'd');
 415     INSERT INTO ef VALUES(1, 'e');
 416   }
 417 } {}
 418 do_test without_rowid3-3.1.3 {
 419   catchsql { UPDATE ab SET a = 5 }
 420 } {1 {CHECK constraint failed: ef}}
 421 do_test without_rowid3-3.1.4 {
 422   execsql { SELECT * FROM ab }
 423 } {1 b}
 424 do_test without_rowid3-3.1.4 {
 425   execsql BEGIN;
 426   catchsql { UPDATE ab SET a = 5 }
 427 } {1 {CHECK constraint failed: ef}}
 428 do_test without_rowid3-3.1.5 {
 429   execsql COMMIT;
 430   execsql { SELECT * FROM ab; SELECT * FROM cd; SELECT * FROM ef }
 431 } {1 b 1 d 1 e}
 432
 433 do_test without_rowid3-3.2.1 {
 434   execsql BEGIN;
 435   catchsql { DELETE FROM ab }
 436 } {1 {FOREIGN KEY constraint failed}}
 437 do_test without_rowid3-3.2.2 {
 438   execsql COMMIT
 439   execsql { SELECT * FROM ab; SELECT * FROM cd; SELECT * FROM ef }
 440 } {1 b 1 d 1 e}
 441
 442 #-------------------------------------------------------------------------
 443 # Test cases without_rowid3-4.* test that recursive foreign key actions
 444 # (i.e. CASCADE) are allowed even if recursive triggers are disabled.
 445 #
 446 drop_all_tables
 447 do_test without_rowid3-4.1 {
 448   execsql {
 449     CREATE TABLE t1(
 450       node PRIMARY KEY,
 451       parent REFERENCES t1 ON DELETE CASCADE
 452     ) WITHOUT rowid;
 453     CREATE TABLE t2(node PRIMARY KEY, parent) WITHOUT rowid;
 454     CREATE TRIGGER t2t AFTER DELETE ON t2 BEGIN
 455       DELETE FROM t2 WHERE parent = old.node;
 456     END;
 457     INSERT INTO t1 VALUES(1, NULL);
 458     INSERT INTO t1 VALUES(2, 1);
 459     INSERT INTO t1 VALUES(3, 1);
 460     INSERT INTO t1 VALUES(4, 2);
 461     INSERT INTO t1 VALUES(5, 2);
 462     INSERT INTO t1 VALUES(6, 3);
 463     INSERT INTO t1 VALUES(7, 3);
 464     INSERT INTO t2 SELECT * FROM t1;
 465   }
 466 } {}
 467 do_test without_rowid3-4.2 {
 468   execsql { PRAGMA recursive_triggers = off }
 469   execsql {
 470     BEGIN;
 471       DELETE FROM t1 WHERE node = 1;
 472       SELECT node FROM t1;
 473   }
 474 } {}
 475 do_test without_rowid3-4.3 {
 476   execsql {
 477       DELETE FROM t2 WHERE node = 1;
 478       SELECT node FROM t2;
 479     ROLLBACK;
 480   }
 481 } {4 5 6 7}
 482 do_test without_rowid3-4.4 {
 483   execsql { PRAGMA recursive_triggers = on }
 484   execsql {
 485     BEGIN;
 486       DELETE FROM t1 WHERE node = 1;
 487       SELECT node FROM t1;
 488   }
 489 } {}
 490 do_test without_rowid3-4.3 {
 491   execsql {
 492       DELETE FROM t2 WHERE node = 1;
 493       SELECT node FROM t2;
 494     ROLLBACK;
 495   }
 496 } {}
 497
 498 #-------------------------------------------------------------------------
 499 # Test cases without_rowid3-5.* verify that the incremental blob API may not
 500 # write to a foreign key column while foreign-keys are enabled.
 501 #
 502 drop_all_tables
 503 ifcapable incrblob {
 504   do_test without_rowid3-5.1 {
 505     execsql {
 506       CREATE TABLE t1(a PRIMARY KEY, b) WITHOUT rowid;
 507       CREATE TABLE t2(a PRIMARY KEY, b REFERENCES t1(a)) WITHOUT rowid;
 508       INSERT INTO t1 VALUES('hello', 'world');
 509       INSERT INTO t2 VALUES('key', 'hello');
 510     }
 511   } {}
 512   do_test without_rowid3-5.2 {
 513     set rc [catch { set fd [db incrblob t2 b 1] } msg]
 514     list $rc $msg
 515   } {1 {cannot open table without rowid: t2}}
 516   do_test without_rowid3-5.5 {
 517     execsql { PRAGMA foreign_keys = on }
 518   } {}
 519 }
 520
 521 drop_all_tables
 522 ifcapable vacuum {
 523   do_test without_rowid3-6.1 {
 524     execsql {
 525       CREATE TABLE t1(a REFERENCES t2(c), b);
 526       CREATE TABLE t2(c UNIQUE, b);
 527       INSERT INTO t2 VALUES(1, 2);
 528       INSERT INTO t1 VALUES(1, 2);
 529       VACUUM;
 530     }
 531   } {}
 532 }
 533
 534 #-------------------------------------------------------------------------
 535 # Test that it is possible to use an INT PRIMARY KEY as the child key
 536 # of a foreign constraint.
 537 #
 538 drop_all_tables
 539 do_test without_rowid3-7.1 {
 540   execsql {
 541     CREATE TABLE t1(a PRIMARY KEY, b) WITHOUT rowid;
 542     CREATE TABLE t2(c INT PRIMARY KEY REFERENCES t1, b) WITHOUT rowid;
 543   }
 544 } {}
 545 do_test without_rowid3-7.2 {
 546   catchsql { INSERT INTO t2 VALUES(1, 'A'); }
 547 } {1 {FOREIGN KEY constraint failed}}
 548 do_test without_rowid3-7.3 {
 549   execsql {
 550     INSERT INTO t1 VALUES(1, 2);
 551     INSERT INTO t1 VALUES(2, 3);
 552     INSERT INTO t2 VALUES(1, 'A');
 553   }
 554 } {}
 555 do_test without_rowid3-7.4 {
 556   execsql { UPDATE t2 SET c = 2 }
 557 } {}
 558 do_test without_rowid3-7.5 {
 559   catchsql { UPDATE t2 SET c = 3 }
 560 } {1 {FOREIGN KEY constraint failed}}
 561 do_test without_rowid3-7.6 {
 562   catchsql { DELETE FROM t1 WHERE a = 2 }
 563 } {1 {FOREIGN KEY constraint failed}}
 564 do_test without_rowid3-7.7 {
 565   execsql { DELETE FROM t1 WHERE a = 1 }
 566 } {}
 567 do_test without_rowid3-7.8 {
 568   catchsql { UPDATE t1 SET a = 3 }
 569 } {1 {FOREIGN KEY constraint failed}}
 570
 571 #-------------------------------------------------------------------------
 572 # Test that it is not possible to enable/disable FK support while a
 573 # transaction is open.
 574 #
 575 drop_all_tables
 576 proc without_rowid3-8-test {tn zSql value} {
 577   do_test without_rowid3-2.8.$tn.1 [list execsql $zSql] {}
 578   do_test without_rowid3-2.8.$tn.2 { execsql "PRAGMA foreign_keys" } $value
 579 }
 580 without_rowid3-8-test  1 { PRAGMA foreign_keys = 0     } 0
 581 without_rowid3-8-test  2 { PRAGMA foreign_keys = 1     } 1
 582 without_rowid3-8-test  3 { BEGIN                       } 1
 583 without_rowid3-8-test  4 { PRAGMA foreign_keys = 0     } 1
 584 without_rowid3-8-test  5 { COMMIT                      } 1
 585 without_rowid3-8-test  6 { PRAGMA foreign_keys = 0     } 0
 586 without_rowid3-8-test  7 { BEGIN                       } 0
 587 without_rowid3-8-test  8 { PRAGMA foreign_keys = 1     } 0
 588 without_rowid3-8-test  9 { COMMIT                      } 0
 589 without_rowid3-8-test 10 { PRAGMA foreign_keys = 1     } 1
 590 without_rowid3-8-test 11 { PRAGMA foreign_keys = off   } 0
 591 without_rowid3-8-test 12 { PRAGMA foreign_keys = on    } 1
 592 without_rowid3-8-test 13 { PRAGMA foreign_keys = no    } 0
 593 without_rowid3-8-test 14 { PRAGMA foreign_keys = yes   } 1
 594 without_rowid3-8-test 15 { PRAGMA foreign_keys = false } 0
 595 without_rowid3-8-test 16 { PRAGMA foreign_keys = true  } 1
 596
 597 #-------------------------------------------------------------------------
 598 # The following tests, without_rowid3-9.*, test SET DEFAULT actions.
 599 #
 600 drop_all_tables
 601 do_test without_rowid3-9.1.1 {
 602   execsql {
 603     CREATE TABLE t1(a INT PRIMARY KEY, b) WITHOUT rowid;
 604     CREATE TABLE t2(
 605       c INT PRIMARY KEY,
 606       d INTEGER DEFAULT 1 REFERENCES t1 ON DELETE SET DEFAULT
 607     ) WITHOUT rowid;
 608     DELETE FROM t1;
 609   }
 610 } {}
 611 do_test without_rowid3-9.1.2 {
 612   execsql {
 613     INSERT INTO t1 VALUES(1, 'one');
 614     INSERT INTO t1 VALUES(2, 'two');
 615     INSERT INTO t2 VALUES(1, 2);
 616     SELECT * FROM t2;
 617     DELETE FROM t1 WHERE a = 2;
 618     SELECT * FROM t2;
 619   }
 620 } {1 2 1 1}
 621 do_test without_rowid3-9.1.3 {
 622   execsql {
 623     INSERT INTO t1 VALUES(2, 'two');
 624     UPDATE t2 SET d = 2;
 625     DELETE FROM t1 WHERE a = 1;
 626     SELECT * FROM t2;
 627   }
 628 } {1 2}
 629 do_test without_rowid3-9.1.4 {
 630   execsql { SELECT * FROM t1 }
 631 } {2 two}
 632 do_test without_rowid3-9.1.5 {
 633   catchsql { DELETE FROM t1 }
 634 } {1 {FOREIGN KEY constraint failed}}
 635
 636 do_test without_rowid3-9.2.1 {
 637   execsql {
 638     CREATE TABLE pp(a, b, c, PRIMARY KEY(b, c)) WITHOUT rowid;
 639     CREATE TABLE cc(d DEFAULT 3, e DEFAULT 1, f DEFAULT 2,
 640         FOREIGN KEY(f, d) REFERENCES pp
 641         ON UPDATE SET DEFAULT
 642         ON DELETE SET NULL
 643     );
 644     INSERT INTO pp VALUES(1, 2, 3);
 645     INSERT INTO pp VALUES(4, 5, 6);
 646     INSERT INTO pp VALUES(7, 8, 9);
 647   }
 648 } {}
 649 do_test without_rowid3-9.2.2 {
 650   execsql {
 651     INSERT INTO cc VALUES(6, 'A', 5);
 652     INSERT INTO cc VALUES(6, 'B', 5);
 653     INSERT INTO cc VALUES(9, 'A', 8);
 654     INSERT INTO cc VALUES(9, 'B', 8);
 655     UPDATE pp SET b = 1 WHERE a = 7;
 656     SELECT * FROM cc;
 657   }
 658 } {6 A 5 6 B 5 3 A 2 3 B 2}
 659 do_test without_rowid3-9.2.3 {
 660   execsql {
 661     DELETE FROM pp WHERE a = 4;
 662     SELECT * FROM cc;
 663   }
 664 } {{} A {} {} B {} 3 A 2 3 B 2}
 665
 666 #-------------------------------------------------------------------------
 667 # The following tests, without_rowid3-10.*, test "foreign key mismatch" and
 668 # other errors.
 669 #
 670 set tn 0
 671 foreach zSql [list {
 672   CREATE TABLE p(a PRIMARY KEY, b) WITHOUT rowid;
 673   CREATE TABLE c(x REFERENCES p(c));
 674 } {
 675   CREATE TABLE c(x REFERENCES v(y));
 676   CREATE VIEW v AS SELECT x AS y FROM c;
 677 } {
 678   CREATE TABLE p(a, b, PRIMARY KEY(a, b)) WITHOUT rowid;
 679   CREATE TABLE c(x REFERENCES p);
 680 } {
 681   CREATE TABLE p(a COLLATE binary, b);
 682   CREATE UNIQUE INDEX i ON p(a COLLATE nocase);
 683   CREATE TABLE c(x REFERENCES p(a));
 684 }] {
 685   drop_all_tables
 686   do_test without_rowid3-10.1.[incr tn] {
 687     execsql $zSql
 688     catchsql { INSERT INTO c DEFAULT VALUES }
 689   } {/1 {foreign key mismatch - "c" referencing "."}/}
 690 }
 691
 692 # "rowid" cannot be used as part of a child or parent key definition
 693 # unless it happens to be the name of an explicitly declared column.
 694 #
 695 do_test without_rowid3-10.2.1 {
 696   drop_all_tables
 697   catchsql {
 698     CREATE TABLE t1(a PRIMARY KEY, b) WITHOUT rowid;
 699     CREATE TABLE t2(c, d, FOREIGN KEY(rowid) REFERENCES t1(a));
 700   }
 701 } {1 {unknown column "rowid" in foreign key definition}}
 702 do_test without_rowid3-10.2.2 {
 703   drop_all_tables
 704   catchsql {
 705     CREATE TABLE t1(a PRIMARY KEY, b) WITHOUT rowid;
 706     CREATE TABLE t2(rowid, d, FOREIGN KEY(rowid) REFERENCES t1(a));
 707   }
 708 } {0 {}}
 709 do_test without_rowid3-10.2.1 {
 710   drop_all_tables
 711   catchsql {
 712     CREATE TABLE t1(a, b);
 713     CREATE TABLE t2(c, d, FOREIGN KEY(c) REFERENCES t1(rowid));
 714     INSERT INTO t1(rowid, a, b) VALUES(1, 1, 1);
 715     INSERT INTO t2 VALUES(1, 1);
 716   }
 717 } {1 {foreign key mismatch - "t2" referencing "t1"}}
 718 do_test without_rowid3-10.2.2 {
 719   drop_all_tables
 720   catchsql {
 721     CREATE TABLE t1(rowid PRIMARY KEY, b) WITHOUT rowid;
 722     CREATE TABLE t2(c, d, FOREIGN KEY(c) REFERENCES t1(rowid));
 723     INSERT INTO t1(rowid, b) VALUES(1, 1);
 724     INSERT INTO t2 VALUES(1, 1);
 725   }
 726 } {0 {}}
 727
 728
 729 #-------------------------------------------------------------------------
 730 # The following tests, without_rowid3-11.*, test CASCADE actions.
 731 #
 732 drop_all_tables
 733 do_test without_rowid3-11.1.1 {
 734   execsql {
 735     CREATE TABLE t1(a INT PRIMARY KEY, b) WITHOUT rowid;
 736     CREATE TABLE t2(c, d, FOREIGN KEY(c) REFERENCES t1(a) ON UPDATE CASCADE);
 737
 738     INSERT INTO t1 VALUES(10, 100);
 739     INSERT INTO t2 VALUES(10, 100);
 740     UPDATE t1 SET a = 15;
 741     SELECT * FROM t2;
 742   }
 743 } {15 100}
 744
 745 #-------------------------------------------------------------------------
 746 # The following tests, without_rowid3-12.*, test RESTRICT actions.
 747 #
 748 drop_all_tables
 749 do_test without_rowid3-12.1.1 {
 750   execsql {
 751     CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT rowid;
 752     CREATE TABLE t2(
 753       x REFERENCES t1 ON UPDATE RESTRICT DEFERRABLE INITIALLY DEFERRED
 754     );
 755     INSERT INTO t1 VALUES(1, 'one');
 756     INSERT INTO t1 VALUES(2, 'two');
 757     INSERT INTO t1 VALUES(3, 'three');
 758   }
 759 } {}
 760 do_test without_rowid3-12.1.2 {
 761   execsql "BEGIN"
 762   execsql "INSERT INTO t2 VALUES('two')"
 763 } {}
 764 do_test without_rowid3-12.1.3 {
 765   execsql "UPDATE t1 SET b = 'four' WHERE b = 'one'"
 766 } {}
 767 do_test without_rowid3-12.1.4 {
 768   catchsql "UPDATE t1 SET b = 'five' WHERE b = 'two'"
 769 } {1 {FOREIGN KEY constraint failed}}
 770 do_test without_rowid3-12.1.5 {
 771   execsql "DELETE FROM t1 WHERE b = 'two'"
 772 } {}
 773 do_test without_rowid3-12.1.6 {
 774   catchsql "COMMIT"
 775 } {1 {FOREIGN KEY constraint failed}}
 776 do_test without_rowid3-12.1.7 {
 777   execsql {
 778     INSERT INTO t1 VALUES(2, 'two');
 779     COMMIT;
 780   }
 781 } {}
 782
 783 drop_all_tables
 784 do_test without_rowid3-12.2.1 {
 785   execsql {
 786     CREATE TABLE t1(x COLLATE NOCASE PRIMARY KEY) WITHOUT rowid;
 787     CREATE TRIGGER tt1 AFTER DELETE ON t1
 788       WHEN EXISTS ( SELECT 1 FROM t2 WHERE old.x = y )
 789     BEGIN
 790       INSERT INTO t1 VALUES(old.x);
 791     END;
 792     CREATE TABLE t2(y REFERENCES t1);
 793     INSERT INTO t1 VALUES('A');
 794     INSERT INTO t1 VALUES('B');
 795     INSERT INTO t2 VALUES('a');
 796     INSERT INTO t2 VALUES('b');
 797
 798     SELECT * FROM t1;
 799     SELECT * FROM t2;
 800   }
 801 } {A B a b}
 802 do_test without_rowid3-12.2.2 {
 803   execsql { DELETE FROM t1 }
 804   execsql {
 805     SELECT * FROM t1;
 806     SELECT * FROM t2;
 807   }
 808 } {A B a b}
 809 do_test without_rowid3-12.2.3 {
 810   execsql {
 811     DROP TABLE t2;
 812     CREATE TABLE t2(y REFERENCES t1 ON DELETE RESTRICT);
 813     INSERT INTO t2 VALUES('a');
 814     INSERT INTO t2 VALUES('b');
 815   }
 816   catchsql { DELETE FROM t1 }
 817 } {1 {FOREIGN KEY constraint failed}}
 818 do_test without_rowid3-12.2.4 {
 819   execsql {
 820     SELECT * FROM t1;
 821     SELECT * FROM t2;
 822   }
 823 } {A B a b}
 824
 825 drop_all_tables
 826 do_test without_rowid3-12.3.1 {
 827   execsql {
 828     CREATE TABLE up(
 829       c00, c01, c02, c03, c04, c05, c06, c07, c08, c09,
 830       c10, c11, c12, c13, c14, c15, c16, c17, c18, c19,
 831       c20, c21, c22, c23, c24, c25, c26, c27, c28, c29,
 832       c30, c31, c32, c33, c34, c35, c36, c37, c38, c39,
 833       PRIMARY KEY(c34, c35)
 834     ) WITHOUT rowid;
 835     CREATE TABLE down(
 836       c00, c01, c02, c03, c04, c05, c06, c07, c08, c09,
 837       c10, c11, c12, c13, c14, c15, c16, c17, c18, c19,
 838       c20, c21, c22, c23, c24, c25, c26, c27, c28, c29,
 839       c30, c31, c32, c33, c34, c35, c36, c37, c38, c39,
 840       FOREIGN KEY(c39, c38) REFERENCES up ON UPDATE CASCADE
 841     );
 842   }
 843 } {}
 844 do_test without_rowid3-12.3.2 {
 845   execsql {
 846     INSERT INTO up(c34, c35) VALUES('yes', 'no');
 847     INSERT INTO down(c39, c38) VALUES('yes', 'no');
 848     UPDATE up SET c34 = 'possibly';
 849     SELECT c38, c39 FROM down;
 850     DELETE FROM down;
 851   }
 852 } {no possibly}
 853 do_test without_rowid3-12.3.3 {
 854   catchsql { INSERT INTO down(c39, c38) VALUES('yes', 'no') }
 855 } {1 {FOREIGN KEY constraint failed}}
 856 do_test without_rowid3-12.3.4 {
 857   execsql {
 858     INSERT INTO up(c34, c35) VALUES('yes', 'no');
 859     INSERT INTO down(c39, c38) VALUES('yes', 'no');
 860   }
 861   catchsql { DELETE FROM up WHERE c34 = 'yes' }
 862 } {1 {FOREIGN KEY constraint failed}}
 863 do_test without_rowid3-12.3.5 {
 864   execsql {
 865     DELETE FROM up WHERE c34 = 'possibly';
 866     SELECT c34, c35 FROM up;
 867     SELECT c39, c38 FROM down;
 868   }
 869 } {yes no yes no}
 870
 871 #-------------------------------------------------------------------------
 872 # The following tests, without_rowid3-13.*, test that FK processing is performed
 873 # when rows are REPLACEd.
 874 #
 875 drop_all_tables
 876 do_test without_rowid3-13.1.1 {
 877   execsql {
 878     CREATE TABLE pp(a UNIQUE, b, c, PRIMARY KEY(b, c)) WITHOUT rowid;
 879     CREATE TABLE cc(d, e, f UNIQUE, FOREIGN KEY(d, e) REFERENCES pp);
 880     INSERT INTO pp VALUES(1, 2, 3);
 881     INSERT INTO cc VALUES(2, 3, 1);
 882   }
 883 } {}
 884 foreach {tn stmt} {
 885   1   "REPLACE INTO pp VALUES(1, 4, 5)"
 886 } {
 887   do_test without_rowid3-13.1.$tn.1 {
 888     catchsql $stmt
 889   } {1 {FOREIGN KEY constraint failed}}
 890   do_test without_rowid3-13.1.$tn.2 {
 891     execsql {
 892       SELECT * FROM pp;
 893       SELECT * FROM cc;
 894     }
 895   } {1 2 3 2 3 1}
 896   do_test without_rowid3-13.1.$tn.3 {
 897     execsql BEGIN;
 898     catchsql $stmt
 899   } {1 {FOREIGN KEY constraint failed}}
 900   do_test without_rowid3-13.1.$tn.4 {
 901     execsql {
 902       COMMIT;
 903       SELECT * FROM pp;
 904       SELECT * FROM cc;
 905     }
 906   } {1 2 3 2 3 1}
 907 }
 908
 909 #-------------------------------------------------------------------------
 910 # The following tests, without_rowid3-14.*, test that the "DROP TABLE" and "ALTER
 911 # TABLE" commands work as expected wrt foreign key constraints.
 912 #
 913 # without_rowid3-14.1*: ALTER TABLE ADD COLUMN
 914 # without_rowid3-14.2*: ALTER TABLE RENAME TABLE
 915 # without_rowid3-14.3*: DROP TABLE
 916 #
 917 drop_all_tables
 918 ifcapable altertable {
 919   do_test without_rowid3-14.1.1 {
 920     # Adding a column with a REFERENCES clause is not supported.
 921     execsql {
 922       CREATE TABLE t1(a PRIMARY KEY) WITHOUT rowid;
 923       CREATE TABLE t2(a, b);
 924     }
 925     catchsql { ALTER TABLE t2 ADD COLUMN c REFERENCES t1 }
 926   } {0 {}}
 927   do_test without_rowid3-14.1.2 {
 928     catchsql { ALTER TABLE t2 ADD COLUMN d DEFAULT NULL REFERENCES t1 }
 929   } {0 {}}
 930   do_test without_rowid3-14.1.3 {
 931     catchsql { ALTER TABLE t2 ADD COLUMN e REFERENCES t1 DEFAULT NULL}
 932   } {0 {}}
 933   do_test without_rowid3-14.1.4 {
 934     catchsql { ALTER TABLE t2 ADD COLUMN f REFERENCES t1 DEFAULT 'text'}
 935   } {1 {Cannot add a REFERENCES column with non-NULL default value}}
 936   do_test without_rowid3-14.1.5 {
 937     catchsql { ALTER TABLE t2 ADD COLUMN g DEFAULT CURRENT_TIME REFERENCES t1 }
 938   } {1 {Cannot add a REFERENCES column with non-NULL default value}}
 939   do_test without_rowid3-14.1.6 {
 940     execsql {
 941       PRAGMA foreign_keys = off;
 942       ALTER TABLE t2 ADD COLUMN h DEFAULT 'text' REFERENCES t1;
 943       PRAGMA foreign_keys = on;
 944       SELECT sql FROM sqlite_master WHERE name='t2';
 945     }
 946   } {{CREATE TABLE t2(a, b, c REFERENCES t1, d DEFAULT NULL REFERENCES t1, e REFERENCES t1 DEFAULT NULL, h DEFAULT 'text' REFERENCES t1)}}
 947
 948
 949   # Test the sqlite_rename_parent() function directly.
 950   #
 951   proc test_rename_parent {zCreate zOld zNew} {
 952     db eval {SELECT sqlite_rename_table(
 953         'main', 'table', 't1', $zCreate, $zOld, $zNew, 0
 954     )}
 955   }
 956   do_test without_rowid3-14.2.1.1 {
 957     test_rename_parent {CREATE TABLE t1(a REFERENCES t2)} t2 t3
 958   } {{CREATE TABLE t1(a REFERENCES "t3")}}
 959   do_test without_rowid3-14.2.1.2 {
 960     test_rename_parent {CREATE TABLE t1(a REFERENCES t2)} t4 t3
 961   } {{CREATE TABLE t1(a REFERENCES t2)}}
 962   do_test without_rowid3-14.2.1.3 {
 963     test_rename_parent {CREATE TABLE t1(a REFERENCES "t2")} t2 t3
 964   } {{CREATE TABLE t1(a REFERENCES "t3")}}
 965
 966   # Test ALTER TABLE RENAME TABLE a bit.
 967   #
 968   do_test without_rowid3-14.2.2.1 {
 969     drop_all_tables
 970     execsql {
 971       CREATE TABLE t1(a PRIMARY KEY, b REFERENCES t1) WITHOUT rowid;
 972       CREATE TABLE t2(a PRIMARY KEY, b REFERENCES t1, c REFERENCES t2)
 973             WITHOUT rowid;
 974       CREATE TABLE t3(a REFERENCES t1, b REFERENCES t2, c REFERENCES t1);
 975     }
 976     execsql { SELECT sql FROM sqlite_master WHERE type = 'table'}
 977   } [list \
 978     {CREATE TABLE t1(a PRIMARY KEY, b REFERENCES t1) WITHOUT rowid}       \
 979     {CREATE TABLE t2(a PRIMARY KEY, b REFERENCES t1, c REFERENCES t2)
 980             WITHOUT rowid}    \
 981     {CREATE TABLE t3(a REFERENCES t1, b REFERENCES t2, c REFERENCES t1)}  \
 982   ]
 983   do_test without_rowid3-14.2.2.2 {
 984     execsql { ALTER TABLE t1 RENAME TO t4 }
 985     execsql { SELECT sql FROM sqlite_master WHERE type = 'table'}
 986   } [list \
 987     {CREATE TABLE "t4"(a PRIMARY KEY, b REFERENCES "t4") WITHOUT rowid}      \
 988     {CREATE TABLE t2(a PRIMARY KEY, b REFERENCES "t4", c REFERENCES t2)
 989             WITHOUT rowid}     \
 990     {CREATE TABLE t3(a REFERENCES "t4", b REFERENCES t2, c REFERENCES "t4")} \
 991   ]
 992   do_test without_rowid3-14.2.2.3 {
 993     catchsql { INSERT INTO t3 VALUES(1, 2, 3) }
 994   } {1 {FOREIGN KEY constraint failed}}
 995   do_test without_rowid3-14.2.2.4 {
 996     execsql { INSERT INTO t4 VALUES(1, NULL) }
 997   } {}
 998   do_test without_rowid3-14.2.2.5 {
 999     catchsql { UPDATE t4 SET b = 5 }
1000   } {1 {FOREIGN KEY constraint failed}}
1001   do_test without_rowid3-14.2.2.6 {
1002     catchsql { UPDATE t4 SET b = 1 }
1003   } {0 {}}
1004   do_test without_rowid3-14.2.2.7 {
1005     execsql { INSERT INTO t3 VALUES(1, NULL, 1) }
1006   } {}
1007
1008   # Repeat for TEMP tables
1009   #
1010   drop_all_tables
1011   do_test without_rowid3-14.1tmp.1 {
1012     # Adding a column with a REFERENCES clause is not supported.
1013     execsql {
1014       CREATE TEMP TABLE t1(a PRIMARY KEY) WITHOUT rowid;
1015       CREATE TEMP TABLE t2(a, b);
1016     }
1017     catchsql { ALTER TABLE t2 ADD COLUMN c REFERENCES t1 }
1018   } {0 {}}
1019   do_test without_rowid3-14.1tmp.2 {
1020     catchsql { ALTER TABLE t2 ADD COLUMN d DEFAULT NULL REFERENCES t1 }
1021   } {0 {}}
1022   do_test without_rowid3-14.1tmp.3 {
1023     catchsql { ALTER TABLE t2 ADD COLUMN e REFERENCES t1 DEFAULT NULL}
1024   } {0 {}}
1025   do_test without_rowid3-14.1tmp.4 {
1026     catchsql { ALTER TABLE t2 ADD COLUMN f REFERENCES t1 DEFAULT 'text'}
1027   } {1 {Cannot add a REFERENCES column with non-NULL default value}}
1028   do_test without_rowid3-14.1tmp.5 {
1029     catchsql { ALTER TABLE t2 ADD COLUMN g DEFAULT CURRENT_TIME REFERENCES t1 }
1030   } {1 {Cannot add a REFERENCES column with non-NULL default value}}
1031   do_test without_rowid3-14.1tmp.6 {
1032     execsql {
1033       PRAGMA foreign_keys = off;
1034       ALTER TABLE t2 ADD COLUMN h DEFAULT 'text' REFERENCES t1;
1035       PRAGMA foreign_keys = on;
1036       SELECT sql FROM temp.sqlite_master WHERE name='t2';
1037     }
1038   } {{CREATE TABLE t2(a, b, c REFERENCES t1, d DEFAULT NULL REFERENCES t1, e REFERENCES t1 DEFAULT NULL, h DEFAULT 'text' REFERENCES t1)}}
1039
1040   do_test without_rowid3-14.2tmp.1.1 {
1041     test_rename_parent {CREATE TABLE t1(a REFERENCES t2)} t2 t3
1042   } {{CREATE TABLE t1(a REFERENCES "t3")}}
1043   do_test without_rowid3-14.2tmp.1.2 {
1044     test_rename_parent {CREATE TABLE t1(a REFERENCES t2)} t4 t3
1045   } {{CREATE TABLE t1(a REFERENCES t2)}}
1046   do_test without_rowid3-14.2tmp.1.3 {
1047     test_rename_parent {CREATE TABLE t1(a REFERENCES "t2")} t2 t3
1048   } {{CREATE TABLE t1(a REFERENCES "t3")}}
1049
1050   # Test ALTER TABLE RENAME TABLE a bit.
1051   #
1052   do_test without_rowid3-14.2tmp.2.1 {
1053     drop_all_tables
1054     execsql {
1055       CREATE TEMP TABLE t1(a PRIMARY KEY, b REFERENCES t1) WITHOUT rowid;
1056       CREATE TEMP TABLE t2(a PRIMARY KEY, b REFERENCES t1, c REFERENCES t2)
1057             WITHOUT rowid;
1058       CREATE TEMP TABLE t3(a REFERENCES t1, b REFERENCES t2, c REFERENCES t1);
1059     }
1060     execsql { SELECT sql FROM sqlite_temp_master WHERE type = 'table'}
1061   } [list \
1062     {CREATE TABLE t1(a PRIMARY KEY, b REFERENCES t1) WITHOUT rowid}       \
1063     {CREATE TABLE t2(a PRIMARY KEY, b REFERENCES t1, c REFERENCES t2)
1064             WITHOUT rowid}    \
1065     {CREATE TABLE t3(a REFERENCES t1, b REFERENCES t2, c REFERENCES t1)}  \
1066   ]
1067   do_test without_rowid3-14.2tmp.2.2 {
1068     execsql { ALTER TABLE t1 RENAME TO t4 }
1069     execsql { SELECT sql FROM temp.sqlite_master WHERE type = 'table'}
1070   } [list \
1071     {CREATE TABLE "t4"(a PRIMARY KEY, b REFERENCES "t4") WITHOUT rowid}      \
1072     {CREATE TABLE t2(a PRIMARY KEY, b REFERENCES "t4", c REFERENCES t2)
1073             WITHOUT rowid}     \
1074     {CREATE TABLE t3(a REFERENCES "t4", b REFERENCES t2, c REFERENCES "t4")} \
1075   ]
1076   do_test without_rowid3-14.2tmp.2.3 {
1077     catchsql { INSERT INTO t3 VALUES(1, 2, 3) }
1078   } {1 {FOREIGN KEY constraint failed}}
1079   do_test without_rowid3-14.2tmp.2.4 {
1080     execsql { INSERT INTO t4 VALUES(1, NULL) }
1081   } {}
1082   do_test without_rowid3-14.2tmp.2.5 {
1083     catchsql { UPDATE t4 SET b = 5 }
1084   } {1 {FOREIGN KEY constraint failed}}
1085   do_test without_rowid3-14.2tmp.2.6 {
1086     catchsql { UPDATE t4 SET b = 1 }
1087   } {0 {}}
1088   do_test without_rowid3-14.2tmp.2.7 {
1089     execsql { INSERT INTO t3 VALUES(1, NULL, 1) }
1090   } {}
1091
1092   # Repeat for ATTACH-ed tables
1093   #
1094   drop_all_tables
1095   do_test without_rowid3-14.1aux.1 {
1096     # Adding a column with a REFERENCES clause is not supported.
1097     execsql {
1098       ATTACH ':memory:' AS aux;
1099       CREATE TABLE aux.t1(a PRIMARY KEY) WITHOUT rowid;
1100       CREATE TABLE aux.t2(a, b);
1101     }
1102     catchsql { ALTER TABLE t2 ADD COLUMN c REFERENCES t1 }
1103   } {0 {}}
1104   do_test without_rowid3-14.1aux.2 {
1105     catchsql { ALTER TABLE t2 ADD COLUMN d DEFAULT NULL REFERENCES t1 }
1106   } {0 {}}
1107   do_test without_rowid3-14.1aux.3 {
1108     catchsql { ALTER TABLE t2 ADD COLUMN e REFERENCES t1 DEFAULT NULL}
1109   } {0 {}}
1110   do_test without_rowid3-14.1aux.4 {
1111     catchsql { ALTER TABLE t2 ADD COLUMN f REFERENCES t1 DEFAULT 'text'}
1112   } {1 {Cannot add a REFERENCES column with non-NULL default value}}
1113   do_test without_rowid3-14.1aux.5 {
1114     catchsql { ALTER TABLE t2 ADD COLUMN g DEFAULT CURRENT_TIME REFERENCES t1 }
1115   } {1 {Cannot add a REFERENCES column with non-NULL default value}}
1116   do_test without_rowid3-14.1aux.6 {
1117     execsql {
1118       PRAGMA foreign_keys = off;
1119       ALTER TABLE t2 ADD COLUMN h DEFAULT 'text' REFERENCES t1;
1120       PRAGMA foreign_keys = on;
1121       SELECT sql FROM aux.sqlite_master WHERE name='t2';
1122     }
1123   } {{CREATE TABLE t2(a, b, c REFERENCES t1, d DEFAULT NULL REFERENCES t1, e REFERENCES t1 DEFAULT NULL, h DEFAULT 'text' REFERENCES t1)}}
1124
1125   do_test without_rowid3-14.2aux.1.1 {
1126     test_rename_parent {CREATE TABLE t1(a REFERENCES t2)} t2 t3
1127   } {{CREATE TABLE t1(a REFERENCES "t3")}}
1128   do_test without_rowid3-14.2aux.1.2 {
1129     test_rename_parent {CREATE TABLE t1(a REFERENCES t2)} t4 t3
1130   } {{CREATE TABLE t1(a REFERENCES t2)}}
1131   do_test without_rowid3-14.2aux.1.3 {
1132     test_rename_parent {CREATE TABLE t1(a REFERENCES "t2")} t2 t3
1133   } {{CREATE TABLE t1(a REFERENCES "t3")}}
1134
1135   # Test ALTER TABLE RENAME TABLE a bit.
1136   #
1137   do_test without_rowid3-14.2aux.2.1 {
1138     drop_all_tables
1139     execsql {
1140       CREATE TABLE aux.t1(a PRIMARY KEY, b REFERENCES t1) WITHOUT rowid;
1141       CREATE TABLE aux.t2(a PRIMARY KEY, b REFERENCES t1, c REFERENCES t2)
1142             WITHOUT rowid;
1143       CREATE TABLE aux.t3(a REFERENCES t1, b REFERENCES t2, c REFERENCES t1);
1144     }
1145     execsql { SELECT sql FROM aux.sqlite_master WHERE type = 'table'}
1146   } [list \
1147     {CREATE TABLE t1(a PRIMARY KEY, b REFERENCES t1) WITHOUT rowid}       \
1148     {CREATE TABLE t2(a PRIMARY KEY, b REFERENCES t1, c REFERENCES t2)
1149             WITHOUT rowid}    \
1150     {CREATE TABLE t3(a REFERENCES t1, b REFERENCES t2, c REFERENCES t1)}  \
1151   ]
1152   do_test without_rowid3-14.2aux.2.2 {
1153     execsql { ALTER TABLE t1 RENAME TO t4 }
1154     execsql { SELECT sql FROM aux.sqlite_master WHERE type = 'table'}
1155   } [list \
1156     {CREATE TABLE "t4"(a PRIMARY KEY, b REFERENCES "t4") WITHOUT rowid}      \
1157     {CREATE TABLE t2(a PRIMARY KEY, b REFERENCES "t4", c REFERENCES t2)
1158             WITHOUT rowid}     \
1159     {CREATE TABLE t3(a REFERENCES "t4", b REFERENCES t2, c REFERENCES "t4")} \
1160   ]
1161   do_test without_rowid3-14.2aux.2.3 {
1162     catchsql { INSERT INTO t3 VALUES(1, 2, 3) }
1163   } {1 {FOREIGN KEY constraint failed}}
1164   do_test without_rowid3-14.2aux.2.4 {
1165     execsql { INSERT INTO t4 VALUES(1, NULL) }
1166   } {}
1167   do_test without_rowid3-14.2aux.2.5 {
1168     catchsql { UPDATE t4 SET b = 5 }
1169   } {1 {FOREIGN KEY constraint failed}}
1170   do_test without_rowid3-14.2aux.2.6 {
1171     catchsql { UPDATE t4 SET b = 1 }
1172   } {0 {}}
1173   do_test without_rowid3-14.2aux.2.7 {
1174     execsql { INSERT INTO t3 VALUES(1, NULL, 1) }
1175   } {}
1176 }
1177
1178 do_test without_rowid3-2.14.3.1 {
1179   drop_all_tables
1180   execsql {
1181     CREATE TABLE t1(a, b REFERENCES nosuchtable);
1182     DROP TABLE t1;
1183   }
1184 } {}
1185 do_test without_rowid3-2.14.3.2 {
1186   execsql {
1187     CREATE TABLE t1(a PRIMARY KEY, b) WITHOUT rowid;
1188     INSERT INTO t1 VALUES('a', 1);
1189     CREATE TABLE t2(x REFERENCES t1);
1190     INSERT INTO t2 VALUES('a');
1191   }
1192 } {}
1193 do_test without_rowid3-2.14.3.3 {
1194   catchsql { DROP TABLE t1 }
1195 } {1 {FOREIGN KEY constraint failed}}
1196 do_test without_rowid3-2.14.3.4 {
1197   execsql {
1198     DELETE FROM t2;
1199     DROP TABLE t1;
1200   }
1201 } {}
1202 do_test without_rowid3-2.14.3.4 {
1203   catchsql { INSERT INTO t2 VALUES('x') }
1204 } {1 {no such table: main.t1}}
1205 do_test without_rowid3-2.14.3.5 {
1206   execsql {
1207     CREATE TABLE t1(x PRIMARY KEY) WITHOUT rowid;
1208     INSERT INTO t1 VALUES('x');
1209   }
1210   execsql { INSERT INTO t2 VALUES('x') }
1211 } {}
1212 do_test without_rowid3-2.14.3.6 {
1213   catchsql { DROP TABLE t1 }
1214 } {1 {FOREIGN KEY constraint failed}}
1215 do_test without_rowid3-2.14.3.7 {
1216   execsql {
1217     DROP TABLE t2;
1218     DROP TABLE t1;
1219   }
1220 } {}
1221 do_test without_rowid3-2.14.3.8 {
1222   execsql {
1223     CREATE TABLE pp(x, y, PRIMARY KEY(x, y)) WITHOUT ROWID;
1224     CREATE TABLE cc(a, b, FOREIGN KEY(a, b) REFERENCES pp(x, z));
1225   }
1226   catchsql { INSERT INTO cc VALUES(1, 2) }
1227 } {1 {foreign key mismatch - "cc" referencing "pp"}}
1228 do_test without_rowid3-2.14.3.9 {
1229   execsql { DROP TABLE cc }
1230 } {}
1231 do_test without_rowid3-2.14.3.10 {
1232   execsql {
1233     CREATE TABLE cc(a, b,
1234       FOREIGN KEY(a, b) REFERENCES pp DEFERRABLE INITIALLY DEFERRED
1235     );
1236   }
1237   execsql {
1238     INSERT INTO pp VALUES('a', 'b');
1239     INSERT INTO cc VALUES('a', 'b');
1240     BEGIN;
1241       DROP TABLE pp;
1242       CREATE TABLE pp(a, b, c, PRIMARY KEY(b, c)) WITHOUT rowid;
1243       INSERT INTO pp VALUES(1, 'a', 'b');
1244     COMMIT;
1245   }
1246 } {}
1247 do_test without_rowid3-2.14.3.11 {
1248   execsql {
1249     BEGIN;
1250       DROP TABLE cc;
1251       DROP TABLE pp;
1252     COMMIT;
1253   }
1254 } {}
1255 do_test without_rowid3-2.14.3.12 {
1256   execsql {
1257     CREATE TABLE b1(a, b);
1258     CREATE TABLE b2(a, b REFERENCES b1);
1259     DROP TABLE b1;
1260   }
1261 } {}
1262 do_test without_rowid3-2.14.3.13 {
1263   execsql {
1264     CREATE TABLE b3(a, b REFERENCES b2 DEFERRABLE INITIALLY DEFERRED);
1265     DROP TABLE b2;
1266   }
1267 } {}
1268
1269 # Test that nothing goes wrong when dropping a table that refers to a view.
1270 # Or dropping a view that an existing FK (incorrectly) refers to. Or either
1271 # of the above scenarios with a virtual table.
1272 drop_all_tables
1273 do_test without_rowid3-2.14.4.1 {
1274   execsql {
1275     CREATE TABLE t1(x REFERENCES v);
1276     CREATE VIEW v AS SELECT * FROM t1;
1277   }
1278 } {}
1279 do_test without_rowid3-2.14.4.2 {
1280   execsql {
1281     DROP VIEW v;
1282   }
1283 } {}
1284 ifcapable vtab {
1285   register_echo_module db
1286   do_test without_rowid3-2.14.4.3 {
1287     execsql { CREATE VIRTUAL TABLE v USING echo(t1) }
1288   } {}
1289   do_test without_rowid3-2.14.4.2 {
1290     execsql {
1291       DROP TABLE v;
1292     }
1293   } {}
1294 }
1295
1296 #-------------------------------------------------------------------------
1297 # The following tests, without_rowid3-15.*, test that unnecessary FK related scans
1298 # and lookups are avoided when the constraint counters are zero.
1299 #
1300 drop_all_tables
1301 proc execsqlS {zSql} {
1302   set ::sqlite_search_count 0
1303   set ::sqlite_found_count 0
1304   set res [uplevel [list execsql $zSql]]
1305   concat [expr $::sqlite_found_count + $::sqlite_search_count] $res
1306 }
1307 do_test without_rowid3-15.1.1 {
1308   execsql {
1309     CREATE TABLE pp(a PRIMARY KEY, b) WITHOUT rowid;
1310     CREATE TABLE cc(x, y REFERENCES pp DEFERRABLE INITIALLY DEFERRED);
1311     INSERT INTO pp VALUES(1, 'one');
1312     INSERT INTO pp VALUES(2, 'two');
1313     INSERT INTO cc VALUES('neung', 1);
1314     INSERT INTO cc VALUES('song', 2);
1315   }
1316 } {}
1317 do_test without_rowid3-15.1.2 {
1318   execsqlS { INSERT INTO pp VALUES(3, 'three') }
1319 } {0}
1320 do_test without_rowid3-15.1.3 {
1321   execsql {
1322     BEGIN;
1323       INSERT INTO cc VALUES('see', 4);    -- Violates deferred constraint
1324   }
1325   execsqlS { INSERT INTO pp VALUES(5, 'five') }
1326 } {2}
1327 do_test without_rowid3-15.1.4 {
1328   execsql { DELETE FROM cc WHERE x = 'see' }
1329   execsqlS { INSERT INTO pp VALUES(6, 'six') }
1330 } {0}
1331 do_test without_rowid3-15.1.5 {
1332   execsql COMMIT
1333 } {}
1334 do_test without_rowid3-15.1.6 {
1335   execsql BEGIN
1336   execsqlS {
1337     DELETE FROM cc WHERE x = 'neung';
1338     ROLLBACK;
1339   }
1340 } {1}
1341 do_test without_rowid3-15.1.7 {
1342   execsql {
1343     BEGIN;
1344     DELETE FROM pp WHERE a = 2;
1345   }
1346   execsqlS {
1347     DELETE FROM cc WHERE x = 'neung';
1348     ROLLBACK;
1349   }
1350 } {2}
1351
1352 #-------------------------------------------------------------------------
1353 # This next block of tests, without_rowid3-16.*, test that rows that refer to
1354 # themselves may be inserted and deleted.
1355 #
1356 foreach {tn zSchema} {
1357   1 { CREATE TABLE self(a INTEGER PRIMARY KEY, b REFERENCES self(a))
1358              WITHOUT rowid }
1359   2 { CREATE TABLE self(a PRIMARY KEY, b REFERENCES self(a)) WITHOUT rowid }
1360   3 { CREATE TABLE self(a UNIQUE, b INT PRIMARY KEY REFERENCES self(a))
1361              WITHOUT rowid }
1362 } {
1363   drop_all_tables
1364   do_test without_rowid3-16.1.$tn.1 {
1365     execsql $zSchema
1366     execsql { INSERT INTO self VALUES(13, 13) }
1367   } {}
1368   do_test without_rowid3-16.1.$tn.2 {
1369     execsql { UPDATE self SET a = 14, b = 14 }
1370   } {}
1371
1372   do_test without_rowid3-16.1.$tn.3 {
1373     catchsql { UPDATE self SET b = 15 }
1374   } {1 {FOREIGN KEY constraint failed}}
1375
1376   do_test without_rowid3-16.1.$tn.4 {
1377     catchsql { UPDATE self SET a = 15 }
1378   } {1 {FOREIGN KEY constraint failed}}
1379
1380   do_test without_rowid3-16.1.$tn.5 {
1381     catchsql { UPDATE self SET a = 15, b = 16 }
1382   } {1 {FOREIGN KEY constraint failed}}
1383
1384   do_test without_rowid3-16.1.$tn.6 {
1385     catchsql { UPDATE self SET a = 17, b = 17 }
1386   } {0 {}}
1387
1388   do_test without_rowid3-16.1.$tn.7 {
1389     execsql { DELETE FROM self }
1390   } {}
1391   do_test without_rowid3-16.1.$tn.8 {
1392     catchsql { INSERT INTO self VALUES(20, 21) }
1393   } {1 {FOREIGN KEY constraint failed}}
1394 }
1395
1396 # Additional tests cases using multi-column self-referential
1397 # FOREIGN KEY constraints.
1398 #
1399 drop_all_tables
1400 do_execsql_test without_rowid3-16.4.1.1 {
1401   PRAGMA foreign_keys=ON;
1402   CREATE TABLE t1(a,b,c,d,e,f,
1403      UNIQUE (a,b),
1404      PRIMARY KEY (e,c),
1405      FOREIGN KEY (d,f) REFERENCES t1(e,c)
1406   ) WITHOUT rowid;
1407   INSERT INTO t1 VALUES(1,2,3,5,5,3);
1408   INSERT INTO t1 VALUES(2,3,4,6,6,4);
1409   INSERT INTO t1 VALUES('x','y',1.5,'fizzle','fizzle',1.5);
1410   SELECT *, '|' FROM t1 ORDER BY a, b;
1411 } {1 2 3 5 5 3 | 2 3 4 6 6 4 | x y 1.5 fizzle fizzle 1.5 |}
1412
1413 do_execsql_test without_rowid3-16.4.1.2 {
1414   UPDATE t1 SET c=99, f=99 WHERE a=1;
1415   SELECT *, '|' FROM t1 ORDER BY a, b;
1416 } {1 2 99 5 5 99 | 2 3 4 6 6 4 | x y 1.5 fizzle fizzle 1.5 |}
1417
1418 do_execsql_test without_rowid3-16.4.1.3 {
1419   UPDATE t1 SET e=876, d=876 WHERE a=2;
1420   SELECT *, '|' FROM t1 ORDER BY a, b;
1421 } {1 2 99 5 5 99 | 2 3 4 876 876 4 | x y 1.5 fizzle fizzle 1.5 |}
1422
1423 do_test without_rowid3-16.4.1.4 {
1424   catchsql {
1425     UPDATE t1 SET c=11, e=22 WHERE a=1;
1426   }
1427 } {1 {FOREIGN KEY constraint failed}}
1428
1429 do_test without_rowid3-16.4.1.5 {
1430   catchsql {
1431     UPDATE t1 SET d=11, f=22 WHERE a=1;
1432   }
1433 } {1 {FOREIGN KEY constraint failed}}
1434
1435 do_execsql_test without_rowid3-16.4.1.6 {
1436   DELETE FROM t1 WHERE a=1;
1437   SELECT *, '|' FROM t1 ORDER BY a, b;
1438 } {2 3 4 876 876 4 | x y 1.5 fizzle fizzle 1.5 |}
1439
1440 do_execsql_test without_rowid3-16.4.2.1 {
1441   DROP TABLE t1;
1442   CREATE TABLE t1(a,b,c,d,e,f,
1443      PRIMARY KEY (a,b),
1444      UNIQUE (e,c),
1445      FOREIGN KEY (d,f) REFERENCES t1(e,c)
1446   ) WITHOUT rowid;
1447   INSERT INTO t1 VALUES(1,2,3,5,5,3);
1448   INSERT INTO t1 VALUES(2,3,4,6,6,4);
1449   INSERT INTO t1 VALUES('x','y',1.5,'fizzle','fizzle',1.5);
1450   SELECT *, '|' FROM t1 ORDER BY a, b;
1451 } {1 2 3 5 5 3 | 2 3 4 6 6 4 | x y 1.5 fizzle fizzle 1.5 |}
1452
1453 do_execsql_test without_rowid3-16.4.2.2 {
1454   UPDATE t1 SET c=99, f=99 WHERE a=1;
1455   SELECT *, '|' FROM t1 ORDER BY a, b;
1456 } {1 2 99 5 5 99 | 2 3 4 6 6 4 | x y 1.5 fizzle fizzle 1.5 |}
1457
1458 do_execsql_test without_rowid3-16.4.2.3 {
1459   UPDATE t1 SET e=876, d=876 WHERE a=2;
1460   SELECT *, '|' FROM t1 ORDER BY a, b;
1461 } {1 2 99 5 5 99 | 2 3 4 876 876 4 | x y 1.5 fizzle fizzle 1.5 |}
1462
1463 do_test without_rowid3-16.4.2.4 {
1464   catchsql {
1465     UPDATE t1 SET c=11, e=22 WHERE a=1;
1466   }
1467 } {1 {FOREIGN KEY constraint failed}}
1468
1469 do_test without_rowid3-16.4.2.5 {
1470   catchsql {
1471     UPDATE t1 SET d=11, f=22 WHERE a=1;
1472   }
1473 } {1 {FOREIGN KEY constraint failed}}
1474
1475 do_execsql_test without_rowid3-16.4.2.6 {
1476   DELETE FROM t1 WHERE a=1;
1477   SELECT *, '|' FROM t1 ORDER BY a, b;
1478 } {2 3 4 876 876 4 | x y 1.5 fizzle fizzle 1.5 |}
1479
1480
1481 #-------------------------------------------------------------------------
1482 # This next block of tests, without_rowid3-17.*, tests that if "PRAGMA count_changes"
1483 # is turned on statements that violate immediate FK constraints return
1484 # SQLITE_CONSTRAINT immediately, not after returning a number of rows.
1485 # Whereas statements that violate deferred FK constraints return the number
1486 # of rows before failing.
1487 #
1488 # Also test that rows modified by FK actions are not counted in either the
1489 # returned row count or the values returned by sqlite3_changes(). Like
1490 # trigger related changes, they are included in sqlite3_total_changes() though.
1491 #
1492 drop_all_tables
1493 do_test without_rowid3-17.1.1 {
1494   execsql { PRAGMA count_changes = 1 }
1495   execsql {
1496     CREATE TABLE one(a, b, c, UNIQUE(b, c));
1497     CREATE TABLE two(d, e, f, FOREIGN KEY(e, f) REFERENCES one(b, c));
1498     INSERT INTO one VALUES(1, 2, 3);
1499   }
1500 } {1}
1501 do_test without_rowid3-17.1.2 {
1502   set STMT [sqlite3_prepare_v2 db "INSERT INTO two VALUES(4, 5, 6)" -1 dummy]
1503   sqlite3_step $STMT
1504 } {SQLITE_CONSTRAINT}
1505 verify_ex_errcode without_rowid3-17.1.2b SQLITE_CONSTRAINT_FOREIGNKEY
1506 ifcapable autoreset {
1507   do_test without_rowid3-17.1.3 {
1508     sqlite3_step $STMT
1509   } {SQLITE_CONSTRAINT}
1510   verify_ex_errcode without_rowid3-17.1.3b SQLITE_CONSTRAINT_FOREIGNKEY
1511 } else {
1512   do_test without_rowid3-17.1.3 {
1513     sqlite3_step $STMT
1514   } {SQLITE_MISUSE}
1515 }
1516 do_test without_rowid3-17.1.4 {
1517   sqlite3_finalize $STMT
1518 } {SQLITE_CONSTRAINT}
1519 verify_ex_errcode without_rowid3-17.1.4b SQLITE_CONSTRAINT_FOREIGNKEY
1520 do_test without_rowid3-17.1.5 {
1521   execsql {
1522     INSERT INTO one VALUES(2, 3, 4);
1523     INSERT INTO one VALUES(3, 4, 5);
1524     INSERT INTO two VALUES(1, 2, 3);
1525     INSERT INTO two VALUES(2, 3, 4);
1526     INSERT INTO two VALUES(3, 4, 5);
1527   }
1528 } {1 1 1 1 1}
1529 do_test without_rowid3-17.1.6 {
1530   catchsql {
1531     BEGIN;
1532       INSERT INTO one VALUES(0, 0, 0);
1533       UPDATE two SET e=e+1, f=f+1;
1534   }
1535 } {1 {FOREIGN KEY constraint failed}}
1536 do_test without_rowid3-17.1.7 {
1537   execsql { SELECT * FROM one }
1538 } {1 2 3 2 3 4 3 4 5 0 0 0}
1539 do_test without_rowid3-17.1.8 {
1540   execsql { SELECT * FROM two }
1541 } {1 2 3 2 3 4 3 4 5}
1542 do_test without_rowid3-17.1.9 {
1543   execsql COMMIT
1544 } {}
1545 do_test without_rowid3-17.1.10 {
1546   execsql {
1547     CREATE TABLE three(
1548       g, h, i,
1549       FOREIGN KEY(h, i) REFERENCES one(b, c) DEFERRABLE INITIALLY DEFERRED
1550     );
1551   }
1552 } {}
1553 do_test without_rowid3-17.1.11 {
1554   set STMT [sqlite3_prepare_v2 db "INSERT INTO three VALUES(7, 8, 9)" -1 dummy]
1555   sqlite3_step $STMT
1556 } {SQLITE_ROW}
1557 do_test without_rowid3-17.1.12 {
1558   sqlite3_column_text $STMT 0
1559 } {1}
1560 do_test without_rowid3-17.1.13 {
1561   sqlite3_step $STMT
1562 } {SQLITE_CONSTRAINT}
1563 verify_ex_errcode without_rowid3-17.1.13b SQLITE_CONSTRAINT_FOREIGNKEY
1564 do_test without_rowid3-17.1.14 {
1565   sqlite3_finalize $STMT
1566 } {SQLITE_CONSTRAINT}
1567 verify_ex_errcode without_rowid3-17.1.14b SQLITE_CONSTRAINT_FOREIGNKEY
1568
1569 drop_all_tables
1570 do_test without_rowid3-17.2.1 {
1571   execsql {
1572     CREATE TABLE high("a'b!" PRIMARY KEY, b) WITHOUT rowid;
1573     CREATE TABLE low(
1574       c,
1575       "d&6" REFERENCES high ON UPDATE CASCADE ON DELETE CASCADE
1576     );
1577   }
1578 } {}
1579 do_test without_rowid3-17.2.2 {
1580   execsql {
1581     INSERT INTO high VALUES('a', 'b');
1582     INSERT INTO low VALUES('b', 'a');
1583   }
1584   db changes
1585 } {1}
1586 set nTotal [db total_changes]
1587 do_test without_rowid3-17.2.3 {
1588   execsql { UPDATE high SET "a'b!" = 'c' }
1589 } {1}
1590 do_test without_rowid3-17.2.4 {
1591   db changes
1592 } {1}
1593 do_test without_rowid3-17.2.5 {
1594   expr [db total_changes] - $nTotal
1595 } {2}
1596 do_test without_rowid3-17.2.6 {
1597   execsql { SELECT * FROM high ; SELECT * FROM low }
1598 } {c b b c}
1599 do_test without_rowid3-17.2.7 {
1600   execsql { DELETE FROM high }
1601 } {1}
1602 do_test without_rowid3-17.2.8 {
1603   db changes
1604 } {1}
1605 do_test without_rowid3-17.2.9 {
1606   expr [db total_changes] - $nTotal
1607 } {4}
1608 do_test without_rowid3-17.2.10 {
1609   execsql { SELECT * FROM high ; SELECT * FROM low }
1610 } {}
1611 execsql { PRAGMA count_changes = 0 }
1612
1613 #-------------------------------------------------------------------------
1614 # Test that the authorization callback works.
1615 #
1616
1617 ifcapable auth {
1618   do_test without_rowid3-18.1 {
1619     execsql {
1620       CREATE TABLE long(a, b PRIMARY KEY, c) WITHOUT rowid;
1621       CREATE TABLE short(d, e, f REFERENCES long);
1622       CREATE TABLE mid(g, h, i REFERENCES long DEFERRABLE INITIALLY DEFERRED);
1623     }
1624   } {}
1625
1626   proc auth {args} {eval lappend ::authargs [lrange $args 0 4]; return SQLITE_OK}
1627   db auth auth
1628
1629   # An insert on the parent table must read the child key of any deferred
1630   # foreign key constraints. But not the child key of immediate constraints.
1631   set authargs {}
1632   do_test without_rowid3-18.2 {
1633     execsql { INSERT INTO long VALUES(1, 2, 3) }
1634     set authargs
1635   } {SQLITE_INSERT long {} main {} SQLITE_READ mid i main {}}
1636
1637   # An insert on the child table of an immediate constraint must read the
1638   # parent key columns (to see if it is a violation or not).
1639   set authargs {}
1640   do_test without_rowid3-18.3 {
1641     execsql { INSERT INTO short VALUES(1, 3, 2) }
1642     set authargs
1643   } {SQLITE_INSERT short {} main {} SQLITE_READ long b main {}}
1644
1645   # As must an insert on the child table of a deferred constraint.
1646   set authargs {}
1647   do_test without_rowid3-18.4 {
1648     execsql { INSERT INTO mid VALUES(1, 3, 2) }
1649     set authargs
1650   } {SQLITE_INSERT mid {} main {} SQLITE_READ long b main {}}
1651
1652   do_test without_rowid3-18.5 {
1653     execsql {
1654       CREATE TABLE nought(a, b PRIMARY KEY, c) WITHOUT rowid;
1655       CREATE TABLE cross(d, e, f,
1656         FOREIGN KEY(e) REFERENCES nought(b) ON UPDATE CASCADE
1657       );
1658     }
1659     execsql { INSERT INTO nought VALUES(2, 1, 2) }
1660     execsql { INSERT INTO cross VALUES(0, 1, 0) }
1661     set authargs [list]
1662     execsql { UPDATE nought SET b = 5 }
1663     set authargs
1664   } {SQLITE_UPDATE nought b main {} SQLITE_READ cross e main {} SQLITE_READ cross e main {} SQLITE_READ nought b main {} SQLITE_READ nought b main {} SQLITE_READ nought b main {} SQLITE_UPDATE cross e main {} SQLITE_READ nought b main {} SQLITE_READ cross e main {} SQLITE_READ nought b main {} SQLITE_READ nought b main {}}
1665
1666   do_test without_rowid3-18.6 {
1667     execsql {SELECT * FROM cross}
1668   } {0 5 0}
1669
1670   do_test without_rowid3-18.7 {
1671     execsql {
1672       CREATE TABLE one(a INT PRIMARY KEY, b) WITHOUT rowid;
1673       CREATE TABLE two(b, c REFERENCES one);
1674       INSERT INTO one VALUES(101, 102);
1675     }
1676     set authargs [list]
1677     execsql { INSERT INTO two VALUES(100, 101); }
1678     set authargs
1679   } {SQLITE_INSERT two {} main {} SQLITE_READ one a main {}}
1680
1681   # Return SQLITE_IGNORE to requests to read from the parent table. This
1682   # causes inserts of non-NULL keys into the child table to fail.
1683   #
1684   rename auth {}
1685   proc auth {args} {
1686     if {[lindex $args 1] == "long"} {return SQLITE_IGNORE}
1687     return SQLITE_OK
1688   }
1689   do_test without_rowid3-18.8 {
1690     catchsql { INSERT INTO short VALUES(1, 3, 2) }
1691   } {1 {FOREIGN KEY constraint failed}}
1692   do_test without_rowid3-18.9 {
1693     execsql { INSERT INTO short VALUES(1, 3, NULL) }
1694   } {}
1695   do_test without_rowid3-18.10 {
1696     execsql { SELECT * FROM short }
1697   } {1 3 2 1 3 {}}
1698   do_test without_rowid3-18.11 {
1699     catchsql { UPDATE short SET f = 2 WHERE f IS NULL }
1700   } {1 {FOREIGN KEY constraint failed}}
1701
1702   db auth {}
1703   unset authargs
1704 }
1705
1706
1707 do_test without_rowid3-19.1 {
1708   execsql {
1709     CREATE TABLE main(id INT PRIMARY KEY) WITHOUT rowid;
1710     CREATE TABLE sub(id INT REFERENCES main(id));
1711     INSERT INTO main VALUES(1);
1712     INSERT INTO main VALUES(2);
1713     INSERT INTO sub VALUES(2);
1714   }
1715 } {}
1716 do_test without_rowid3-19.2 {
1717   set S [sqlite3_prepare_v2 db "DELETE FROM main WHERE id = ?" -1 dummy]
1718   sqlite3_bind_int $S 1 2
1719   sqlite3_step $S
1720 } {SQLITE_CONSTRAINT}
1721 verify_ex_errcode without_rowid3-19.2b SQLITE_CONSTRAINT_FOREIGNKEY
1722 do_test without_rowid3-19.3 {
1723   sqlite3_reset $S
1724 } {SQLITE_CONSTRAINT}
1725 verify_ex_errcode without_rowid3-19.3b SQLITE_CONSTRAINT_FOREIGNKEY
1726 do_test without_rowid3-19.4 {
1727   sqlite3_bind_int $S 1 1
1728   sqlite3_step $S
1729 } {SQLITE_DONE}
1730 do_test without_rowid3-19.4 {
1731   sqlite3_finalize $S
1732 } {SQLITE_OK}
1733
1734 drop_all_tables
1735 do_test without_rowid3-20.1 {
1736   execsql {
1737     CREATE TABLE pp(a PRIMARY KEY, b) WITHOUT rowid;
1738     CREATE TABLE cc(c PRIMARY KEY, d REFERENCES pp) WITHOUT rowid;
1739   }
1740 } {}
1741
1742 foreach {tn insert} {
1743   1 "INSERT"
1744   2 "INSERT OR IGNORE"
1745   3 "INSERT OR ABORT"
1746   4 "INSERT OR ROLLBACK"
1747   5 "INSERT OR REPLACE"
1748   6 "INSERT OR FAIL"
1749 } {
1750   do_test without_rowid3-20.2.$tn.1 {
1751     catchsql "$insert INTO cc VALUES(1, 2)"
1752   } {1 {FOREIGN KEY constraint failed}}
1753   do_test without_rowid3-20.2.$tn.2 {
1754     execsql { SELECT * FROM cc }
1755   } {}
1756   do_test without_rowid3-20.2.$tn.3 {
1757     execsql {
1758       BEGIN;
1759         INSERT INTO pp VALUES(2, 'two');
1760         INSERT INTO cc VALUES(1, 2);
1761     }
1762     catchsql "$insert INTO cc VALUES(3, 4)"
1763   } {1 {FOREIGN KEY constraint failed}}
1764   do_test without_rowid3-20.2.$tn.4 {
1765     execsql { COMMIT ; SELECT * FROM cc }
1766   } {1 2}
1767   do_test without_rowid3-20.2.$tn.5 {
1768     execsql { DELETE FROM cc ; DELETE FROM pp }
1769   } {}
1770 }
1771
1772 foreach {tn update} {
1773   1 "UPDATE"
1774   2 "UPDATE OR IGNORE"
1775   3 "UPDATE OR ABORT"
1776   4 "UPDATE OR ROLLBACK"
1777   5 "UPDATE OR REPLACE"
1778   6 "UPDATE OR FAIL"
1779 } {
1780   do_test without_rowid3-20.3.$tn.1 {
1781     execsql {
1782       INSERT INTO pp VALUES(2, 'two');
1783       INSERT INTO cc VALUES(1, 2);
1784     }
1785   } {}
1786   do_test without_rowid3-20.3.$tn.2 {
1787     catchsql "$update pp SET a = 1"
1788   } {1 {FOREIGN KEY constraint failed}}
1789   do_test without_rowid3-20.3.$tn.3 {
1790     execsql { SELECT * FROM pp }
1791   } {2 two}
1792   do_test without_rowid3-20.3.$tn.4 {
1793     catchsql "$update cc SET d = 1"
1794   } {1 {FOREIGN KEY constraint failed}}
1795   do_test without_rowid3-20.3.$tn.5 {
1796     execsql { SELECT * FROM cc }
1797   } {1 2}
1798   do_test without_rowid3-20.3.$tn.6 {
1799     execsql {
1800       BEGIN;
1801         INSERT INTO pp VALUES(3, 'three');
1802     }
1803     catchsql "$update pp SET a = 1 WHERE a = 2"
1804   } {1 {FOREIGN KEY constraint failed}}
1805   do_test without_rowid3-20.3.$tn.7 {
1806     execsql { COMMIT ; SELECT * FROM pp }
1807   } {2 two 3 three}
1808   do_test without_rowid3-20.3.$tn.8 {
1809     execsql {
1810       BEGIN;
1811         INSERT INTO cc VALUES(2, 2);
1812     }
1813     catchsql "$update cc SET d = 1 WHERE c = 1"
1814   } {1 {FOREIGN KEY constraint failed}}
1815   do_test without_rowid3-20.3.$tn.9 {
1816     execsql { COMMIT ; SELECT * FROM cc }
1817   } {1 2 2 2}
1818   do_test without_rowid3-20.3.$tn.10 {
1819     execsql { DELETE FROM cc ; DELETE FROM pp }
1820   } {}
1821 }
1822
1823 #-------------------------------------------------------------------------
1824 # The following block of tests, those prefixed with "without_rowid3-genfkey.",
1825 # are the same tests that were used to test the ".genfkey" command provided
1826 # by the shell tool. So these tests show that the built-in foreign key
1827 # implementation is more or less compatible with the triggers generated
1828 # by genfkey.
1829 #
1830 drop_all_tables
1831 do_test without_rowid3-genfkey.1.1 {
1832   execsql {
1833     CREATE TABLE t1(a INT PRIMARY KEY, b, c, UNIQUE(b, c)) WITHOUT rowid;
1834     CREATE TABLE t2(e REFERENCES t1, f);
1835     CREATE TABLE t3(g, h, i, FOREIGN KEY (h, i) REFERENCES t1(b, c));
1836   }
1837 } {}
1838 do_test without_rowid3-genfkey.1.2 {
1839   catchsql { INSERT INTO t2 VALUES(1, 2) }
1840 } {1 {FOREIGN KEY constraint failed}}
1841 do_test without_rowid3-genfkey.1.3 {
1842   execsql {
1843     INSERT INTO t1 VALUES(1, 2, 3);
1844     INSERT INTO t2 VALUES(1, 2);
1845   }
1846 } {}
1847 do_test without_rowid3-genfkey.1.4 {
1848   execsql { INSERT INTO t2 VALUES(NULL, 3) }
1849 } {}
1850 do_test without_rowid3-genfkey.1.5 {
1851   catchsql { UPDATE t2 SET e = 5 WHERE e IS NULL }
1852 } {1 {FOREIGN KEY constraint failed}}
1853 do_test without_rowid3-genfkey.1.6 {
1854   execsql { UPDATE t2 SET e = 1 WHERE e IS NULL }
1855 } {}
1856 do_test without_rowid3-genfkey.1.7 {
1857   execsql { UPDATE t2 SET e = NULL WHERE f = 3 }
1858 } {}
1859 do_test without_rowid3-genfkey.1.8 {
1860   catchsql { UPDATE t1 SET a = 10 }
1861 } {1 {FOREIGN KEY constraint failed}}
1862 do_test without_rowid3-genfkey.1.9 {
1863   catchsql { UPDATE t1 SET a = NULL }
1864 } {1 {NOT NULL constraint failed: t1.a}}
1865 do_test without_rowid3-genfkey.1.10 {
1866   catchsql { DELETE FROM t1 }
1867 } {1 {FOREIGN KEY constraint failed}}
1868 do_test without_rowid3-genfkey.1.11 {
1869   execsql { UPDATE t2 SET e = NULL }
1870 } {}
1871 do_test without_rowid3-genfkey.1.12 {
1872   execsql {
1873     UPDATE t1 SET a = 10;
1874     DELETE FROM t1;
1875     DELETE FROM t2;
1876   }
1877 } {}
1878 do_test without_rowid3-genfkey.1.13 {
1879   execsql {
1880     INSERT INTO t3 VALUES(1, NULL, NULL);
1881     INSERT INTO t3 VALUES(1, 2, NULL);
1882     INSERT INTO t3 VALUES(1, NULL, 3);
1883   }
1884 } {}
1885 do_test without_rowid3-genfkey.1.14 {
1886   catchsql { INSERT INTO t3 VALUES(3, 1, 4) }
1887 } {1 {FOREIGN KEY constraint failed}}
1888 do_test without_rowid3-genfkey.1.15 {
1889   execsql {
1890     INSERT INTO t1 VALUES(1, 1, 4);
1891     INSERT INTO t3 VALUES(3, 1, 4);
1892   }
1893 } {}
1894 do_test without_rowid3-genfkey.1.16 {
1895   catchsql { DELETE FROM t1 }
1896 } {1 {FOREIGN KEY constraint failed}}
1897 do_test without_rowid3-genfkey.1.17 {
1898   catchsql { UPDATE t1 SET b = 10}
1899 } {1 {FOREIGN KEY constraint failed}}
1900 do_test without_rowid3-genfkey.1.18 {
1901   execsql { UPDATE t1 SET a = 10}
1902 } {}
1903 do_test without_rowid3-genfkey.1.19 {
1904   catchsql { UPDATE t3 SET h = 'hello' WHERE i = 3}
1905 } {1 {FOREIGN KEY constraint failed}}
1906
1907 drop_all_tables
1908 do_test without_rowid3-genfkey.2.1 {
1909   execsql {
1910     CREATE TABLE t1(a INT PRIMARY KEY, b, c, UNIQUE(b, c)) WITHOUT rowid;
1911     CREATE TABLE t2(e REFERENCES t1 ON UPDATE CASCADE ON DELETE CASCADE, f);
1912     CREATE TABLE t3(g, h, i,
1913         FOREIGN KEY (h, i)
1914         REFERENCES t1(b, c) ON UPDATE CASCADE ON DELETE CASCADE
1915     );
1916   }
1917 } {}
1918 do_test without_rowid3-genfkey.2.2 {
1919   execsql {
1920     INSERT INTO t1 VALUES(1, 2, 3);
1921     INSERT INTO t1 VALUES(4, 5, 6);
1922     INSERT INTO t2 VALUES(1, 'one');
1923     INSERT INTO t2 VALUES(4, 'four');
1924   }
1925 } {}
1926 do_test without_rowid3-genfkey.2.3 {
1927   execsql {
1928     UPDATE t1 SET a = 2 WHERE a = 1;
1929     SELECT * FROM t2;
1930   }
1931 } {2 one 4 four}
1932 do_test without_rowid3-genfkey.2.4 {
1933   execsql {
1934     DELETE FROM t1 WHERE a = 4;
1935     SELECT * FROM t2;
1936   }
1937 } {2 one}
1938
1939 do_test without_rowid3-genfkey.2.5 {
1940   execsql {
1941     INSERT INTO t3 VALUES('hello', 2, 3);
1942     UPDATE t1 SET c = 2;
1943     SELECT * FROM t3;
1944   }
1945 } {hello 2 2}
1946 do_test without_rowid3-genfkey.2.6 {
1947   execsql {
1948     DELETE FROM t1;
1949     SELECT * FROM t3;
1950   }
1951 } {}
1952
1953 drop_all_tables
1954 do_test without_rowid3-genfkey.3.1 {
1955   execsql {
1956     CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, UNIQUE(c, b)) WITHOUT rowid;
1957     CREATE TABLE t2(e REFERENCES t1 ON UPDATE SET NULL ON DELETE SET NULL, f);
1958     CREATE TABLE t3(g, h, i,
1959         FOREIGN KEY (h, i)
1960         REFERENCES t1(b, c) ON UPDATE SET NULL ON DELETE SET NULL
1961     );
1962   }
1963 } {}
1964 do_test without_rowid3-genfkey.3.2 {
1965   execsql {
1966     INSERT INTO t1 VALUES(1, 2, 3);
1967     INSERT INTO t1 VALUES(4, 5, 6);
1968     INSERT INTO t2 VALUES(1, 'one');
1969     INSERT INTO t2 VALUES(4, 'four');
1970   }
1971 } {}
1972 do_test without_rowid3-genfkey.3.3 {
1973   execsql {
1974     UPDATE t1 SET a = 2 WHERE a = 1;
1975     SELECT * FROM t2;
1976   }
1977 } {{} one 4 four}
1978 do_test without_rowid3-genfkey.3.4 {
1979   execsql {
1980     DELETE FROM t1 WHERE a = 4;
1981     SELECT * FROM t2;
1982   }
1983 } {{} one {} four}
1984 do_test without_rowid3-genfkey.3.5 {
1985   execsql {
1986     INSERT INTO t3 VALUES('hello', 2, 3);
1987     UPDATE t1 SET c = 2;
1988     SELECT * FROM t3;
1989   }
1990 } {hello {} {}}
1991 do_test without_rowid3-genfkey.3.6 {
1992   execsql {
1993     UPDATE t3 SET h = 2, i = 2;
1994     DELETE FROM t1;
1995     SELECT * FROM t3;
1996   }
1997 } {hello {} {}}
1998
1999 #-------------------------------------------------------------------------
2000 # Verify that ticket dd08e5a988d00decc4a543daa8dbbfab9c577ad8 has been
2001 # fixed.
2002 #
2003 do_test without_rowid3-dd08e5.1.1 {
2004   execsql {
2005     PRAGMA foreign_keys=ON;
2006     CREATE TABLE tdd08(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
2007     CREATE UNIQUE INDEX idd08 ON tdd08(a,b);
2008     INSERT INTO tdd08 VALUES(200,300);
2009
2010     CREATE TABLE tdd08_b(w,x,y, FOREIGN KEY(x,y) REFERENCES tdd08(a,b));
2011     INSERT INTO tdd08_b VALUES(100,200,300);
2012   }
2013 } {}
2014 do_test without_rowid3-dd08e5.1.2 {
2015   catchsql {
2016     DELETE FROM tdd08;
2017   }
2018 } {1 {FOREIGN KEY constraint failed}}
2019 do_test without_rowid3-dd08e5.1.3 {
2020   execsql {
2021     SELECT * FROM tdd08;
2022   }
2023 } {200 300}
2024 do_test without_rowid3-dd08e5.1.4 {
2025   catchsql {
2026     INSERT INTO tdd08_b VALUES(400,500,300);
2027   }
2028 } {1 {FOREIGN KEY constraint failed}}
2029 do_test without_rowid3-dd08e5.1.5 {
2030   catchsql {
2031     UPDATE tdd08_b SET x=x+1;
2032   }
2033 } {1 {FOREIGN KEY constraint failed}}
2034 do_test without_rowid3-dd08e5.1.6 {
2035   catchsql {
2036     UPDATE tdd08 SET a=a+1;
2037   }
2038 } {1 {FOREIGN KEY constraint failed}}
2039
2040 #-------------------------------------------------------------------------
2041 # Verify that ticket ce7c133ea6cc9ccdc1a60d80441f80b6180f5eba
2042 # fixed.
2043 #
2044 do_test without_rowid3-ce7c13.1.1 {
2045   execsql {
2046     CREATE TABLE tce71(a INTEGER PRIMARY KEY, b) WITHOUT rowid;
2047     CREATE UNIQUE INDEX ice71 ON tce71(a,b);
2048     INSERT INTO tce71 VALUES(100,200);
2049     CREATE TABLE tce72(w, x, y, FOREIGN KEY(x,y) REFERENCES tce71(a,b));
2050     INSERT INTO tce72 VALUES(300,100,200);
2051     UPDATE tce71 set b = 200 where a = 100;
2052     SELECT * FROM tce71, tce72;
2053   }
2054 } {100 200 300 100 200}
2055 do_test without_rowid3-ce7c13.1.2 {
2056   catchsql {
2057     UPDATE tce71 set b = 201 where a = 100;
2058   }
2059 } {1 {FOREIGN KEY constraint failed}}
2060 do_test without_rowid3-ce7c13.1.3 {
2061   catchsql {
2062     UPDATE tce71 set a = 101 where a = 100;
2063   }
2064 } {1 {FOREIGN KEY constraint failed}}
2065 do_test without_rowid3-ce7c13.1.4 {
2066   execsql {
2067     CREATE TABLE tce73(a INTEGER PRIMARY KEY, b, UNIQUE(a,b)) WITHOUT rowid;
2068     INSERT INTO tce73 VALUES(100,200);
2069     CREATE TABLE tce74(w, x, y, FOREIGN KEY(x,y) REFERENCES tce73(a,b));
2070     INSERT INTO tce74 VALUES(300,100,200);
2071     UPDATE tce73 set b = 200 where a = 100;
2072     SELECT * FROM tce73, tce74;
2073   }
2074 } {100 200 300 100 200}
2075 do_test without_rowid3-ce7c13.1.5 {
2076   catchsql {
2077     UPDATE tce73 set b = 201 where a = 100;
2078   }
2079 } {1 {FOREIGN KEY constraint failed}}
2080 do_test without_rowid3-ce7c13.1.6 {
2081   catchsql {
2082     UPDATE tce73 set a = 101 where a = 100;
2083   }
2084 } {1 {FOREIGN KEY constraint failed}}
2085
2086 # Confirm that changes() works on WITHOUT ROWID tables that use the
2087 # xfer optimization.
2088 #
2089 db close
2090 sqlite3 db :memory:
2091 do_execsql_test without_rowid3-30.1 {
2092   CREATE TABLE t1(a,b,PRIMARY KEY(a,b)) WITHOUT ROWID;
2093   CREATE TABLE t2(a,b,PRIMARY KEY(a,b)) WITHOUT ROWID;
2094   INSERT INTO t1 VALUES(1,2),(3,4),(5,6);
2095   SELECT changes();
2096 } {3}
2097 do_execsql_test without_rowid3-30.2 {
2098   INSERT INTO t2 SELECT * FROM t1;
2099   SELECT changes();
2100 } {3}
2101
2102 finish_test