Import SQLite 3.8.7.4.

third_party/sqlite/src/test/fkey2.test

 # 2009 September 15
 #
 # The author disclaims copyright to this source code.  In place of
 # a legal notice, here is a blessing:
 #
 #    May you do good and not evil.
 #    May you find forgiveness for yourself and forgive others.
 #    May you share freely, never taking more than you give.
 #
 #***********************************************************************
@@ skipping 86 matching lines @@
 
   CREATE TABLE t7(a, b INTEGER PRIMARY KEY);
   CREATE TABLE t8(c REFERENCES t7 /D/, d);
 
   CREATE TABLE t9(a REFERENCES nosuchtable, b);
   CREATE TABLE t10(a REFERENCES t9(c) /D/, b);
 }
 
 
 set FkeySimpleTests {
-  1.1  "INSERT INTO t2 VALUES(1, 3)"      {1 {foreign key constraint failed}}
+  1.1  "INSERT INTO t2 VALUES(1, 3)"      {1 {FOREIGN KEY constraint failed}}
   1.2  "INSERT INTO t1 VALUES(1, 2)"      {0 {}}
   1.3  "INSERT INTO t2 VALUES(1, 3)"      {0 {}}
-  1.4  "INSERT INTO t2 VALUES(2, 4)"      {1 {foreign key constraint failed}}
+  1.4  "INSERT INTO t2 VALUES(2, 4)"      {1 {FOREIGN KEY constraint failed}}
   1.5  "INSERT INTO t2 VALUES(NULL, 4)"   {0 {}}
-  1.6  "UPDATE t2 SET c=2 WHERE d=4"      {1 {foreign key constraint failed}}
+  1.6  "UPDATE t2 SET c=2 WHERE d=4"      {1 {FOREIGN KEY constraint failed}}
   1.7  "UPDATE t2 SET c=1 WHERE d=4"      {0 {}}
   1.9  "UPDATE t2 SET c=1 WHERE d=4"      {0 {}}
   1.10 "UPDATE t2 SET c=NULL WHERE d=4"   {0 {}}
-  1.11 "DELETE FROM t1 WHERE a=1"         {1 {foreign key constraint failed}}
-  1.12 "UPDATE t1 SET a = 2"              {1 {foreign key constraint failed}}
+  1.11 "DELETE FROM t1 WHERE a=1"         {1 {FOREIGN KEY constraint failed}}
+  1.12 "UPDATE t1 SET a = 2"              {1 {FOREIGN KEY constraint failed}}
   1.13 "UPDATE t1 SET a = 1"              {0 {}}
 
-  2.1  "INSERT INTO t4 VALUES(1, 3)"      {1 {foreign key constraint failed}}
+  2.1  "INSERT INTO t4 VALUES(1, 3)"      {1 {FOREIGN KEY constraint failed}}
   2.2  "INSERT INTO t3 VALUES(1, 2)"      {0 {}}
   2.3  "INSERT INTO t4 VALUES(1, 3)"      {0 {}}
 
-  4.1  "INSERT INTO t8 VALUES(1, 3)"      {1 {foreign key constraint failed}}
+  4.1  "INSERT INTO t8 VALUES(1, 3)"      {1 {FOREIGN KEY constraint failed}}
   4.2  "INSERT INTO t7 VALUES(2, 1)"      {0 {}}
   4.3  "INSERT INTO t8 VALUES(1, 3)"      {0 {}}
-  4.4  "INSERT INTO t8 VALUES(2, 4)"      {1 {foreign key constraint failed}}
+  4.4  "INSERT INTO t8 VALUES(2, 4)"      {1 {FOREIGN KEY constraint failed}}
   4.5  "INSERT INTO t8 VALUES(NULL, 4)"   {0 {}}
-  4.6  "UPDATE t8 SET c=2 WHERE d=4"      {1 {foreign key constraint failed}}
+  4.6  "UPDATE t8 SET c=2 WHERE d=4"      {1 {FOREIGN KEY constraint failed}}
   4.7  "UPDATE t8 SET c=1 WHERE d=4"      {0 {}}
   4.9  "UPDATE t8 SET c=1 WHERE d=4"      {0 {}}
   4.10 "UPDATE t8 SET c=NULL WHERE d=4"   {0 {}}
-  4.11 "DELETE FROM t7 WHERE b=1"         {1 {foreign key constraint failed}}
-  4.12 "UPDATE t7 SET b = 2"              {1 {foreign key constraint failed}}
+  4.11 "DELETE FROM t7 WHERE b=1"         {1 {FOREIGN KEY constraint failed}}
+  4.12 "UPDATE t7 SET b = 2"              {1 {FOREIGN KEY constraint failed}}
   4.13 "UPDATE t7 SET b = 1"              {0 {}}
-  4.14 "INSERT INTO t8 VALUES('a', 'b')"  {1 {foreign key constraint failed}}
-  4.15 "UPDATE t7 SET b = 5"              {1 {foreign key constraint failed}}
-  4.16 "UPDATE t7 SET rowid = 5"          {1 {foreign key constraint failed}}
+  4.14 "INSERT INTO t8 VALUES('a', 'b')"  {1 {FOREIGN KEY constraint failed}}
+  4.15 "UPDATE t7 SET b = 5"              {1 {FOREIGN KEY constraint failed}}
+  4.16 "UPDATE t7 SET rowid = 5"          {1 {FOREIGN KEY constraint failed}}
   4.17 "UPDATE t7 SET a = 10"             {0 {}}
 
   5.1  "INSERT INTO t9 VALUES(1, 3)"      {1 {no such table: main.nosuchtable}}
-  5.2  "INSERT INTO t10 VALUES(1, 3)"     {1 {foreign key mismatch}}
+  5.2  "INSERT INTO t10 VALUES(1, 3)"  
+                            {1 {foreign key mismatch - "t10" referencing "t9"}}
 }
 
 do_test fkey2-1.1.0 {
   execsql [string map {/D/ {}} $FkeySimpleSchema]
 } {}
 foreach {tn zSql res} $FkeySimpleTests {
-  do_test fkey2-1.1.$tn { catchsql $zSql } $res
+  do_test fkey2-1.1.$tn.1 { catchsql $zSql } $res
+  do_test fkey2-1.1.$tn.2 { execsql {PRAGMA foreign_key_check(t1)} } {}
+  do_test fkey2-1.1.$tn.3 { execsql {PRAGMA foreign_key_check(t2)} } {}
+  do_test fkey2-1.1.$tn.4 { execsql {PRAGMA foreign_key_check(t3)} } {}
+  do_test fkey2-1.1.$tn.5 { execsql {PRAGMA foreign_key_check(t4)} } {}
+  do_test fkey2-1.1.$tn.6 { execsql {PRAGMA foreign_key_check(t7)} } {}
+  do_test fkey2-1.1.$tn.7 { execsql {PRAGMA foreign_key_check(t8)} } {}
 }
 drop_all_tables
 
 do_test fkey2-1.2.0 {
   execsql [string map {/D/ {DEFERRABLE INITIALLY DEFERRED}} $FkeySimpleSchema]
 } {}
 foreach {tn zSql res} $FkeySimpleTests {
   do_test fkey2-1.2.$tn { catchsql $zSql } $res
+  do_test fkey2-1.2.$tn.2 { execsql {PRAGMA foreign_key_check(t1)} } {}
+  do_test fkey2-1.2.$tn.3 { execsql {PRAGMA foreign_key_check(t2)} } {}
+  do_test fkey2-1.2.$tn.4 { execsql {PRAGMA foreign_key_check(t3)} } {}
+  do_test fkey2-1.2.$tn.5 { execsql {PRAGMA foreign_key_check(t4)} } {}
+  do_test fkey2-1.2.$tn.6 { execsql {PRAGMA foreign_key_check(t7)} } {}
+  do_test fkey2-1.2.$tn.7 { execsql {PRAGMA foreign_key_check(t8)} } {}
 }
 drop_all_tables
 
 do_test fkey2-1.3.0 {
   execsql [string map {/D/ {}} $FkeySimpleSchema]
   execsql { PRAGMA count_changes = 1 }
 } {}
 foreach {tn zSql res} $FkeySimpleTests {
   if {$res == "0 {}"} { set res {0 1} }
   do_test fkey2-1.3.$tn { catchsql $zSql } $res
+  do_test fkey2-1.3.$tn.2 { execsql {PRAGMA foreign_key_check(t1)} } {}
+  do_test fkey2-1.3.$tn.3 { execsql {PRAGMA foreign_key_check(t2)} } {}
+  do_test fkey2-1.3.$tn.4 { execsql {PRAGMA foreign_key_check(t3)} } {}
+  do_test fkey2-1.3.$tn.5 { execsql {PRAGMA foreign_key_check(t4)} } {}
+  do_test fkey2-1.3.$tn.6 { execsql {PRAGMA foreign_key_check(t7)} } {}
+  do_test fkey2-1.3.$tn.7 { execsql {PRAGMA foreign_key_check(t8)} } {}
 }
 execsql { PRAGMA count_changes = 0 }
 drop_all_tables
 
 do_test fkey2-1.4.0 {
   execsql [string map {/D/ {}} $FkeySimpleSchema]
   execsql { PRAGMA count_changes = 1 }
 } {}
 foreach {tn zSql res} $FkeySimpleTests {
   if {$res == "0 {}"} { set res {0 1} }
@@ skipping 11 matching lines @@
   execsql {
     CREATE TABLE i(i INTEGER PRIMARY KEY);
     CREATE TABLE j(j REFERENCES i);
     INSERT INTO i VALUES(35);
     INSERT INTO j VALUES('35.0');
     SELECT j, typeof(j) FROM j;
   }
 } {35.0 text}
 do_test fkey2-1.5.2 {
   catchsql { DELETE FROM i }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 # Same test using a regular primary key with integer affinity.
 drop_all_tables
 do_test fkey2-1.6.1 {
   execsql {
     CREATE TABLE i(i INT UNIQUE);
     CREATE TABLE j(j REFERENCES i(i));
     INSERT INTO i VALUES('35.0');
     INSERT INTO j VALUES('35.0');
     SELECT j, typeof(j) FROM j;
     SELECT i, typeof(i) FROM i;
   }
 } {35.0 text 35 integer}
 do_test fkey2-1.6.2 {
   catchsql { DELETE FROM i }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 # Use a collation sequence on the parent key.
 drop_all_tables
 do_test fkey2-1.7.1 {
   execsql {
     CREATE TABLE i(i TEXT COLLATE nocase PRIMARY KEY);
     CREATE TABLE j(j TEXT COLLATE binary REFERENCES i(i));
     INSERT INTO i VALUES('SQLite');
     INSERT INTO j VALUES('sqlite');
   }
   catchsql { DELETE FROM i }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 # Use the parent key collation even if it is default and the child key
 # has an explicit value.
 drop_all_tables
 do_test fkey2-1.7.2 {
   execsql {
     CREATE TABLE i(i TEXT PRIMARY KEY);        -- Colseq is "BINARY"
     CREATE TABLE j(j TEXT COLLATE nocase REFERENCES i(i));
     INSERT INTO i VALUES('SQLite');
   }
   catchsql { INSERT INTO j VALUES('sqlite') }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-1.7.3 {
   execsql {
     INSERT INTO i VALUES('sqlite');
     INSERT INTO j VALUES('sqlite');
     DELETE FROM i WHERE i = 'SQLite';
   }
   catchsql { DELETE FROM i WHERE i = 'sqlite' }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 #-------------------------------------------------------------------------
 # This section (test cases fkey2-2.*) contains tests to check that the
 # deferred foreign key constraint logic works.
 #
 proc fkey2-2-test {tn nocommit sql {res {}}} {
   if {$res eq "FKV"} {
-    set expected {1 {foreign key constraint failed}}
+    set expected {1 {FOREIGN KEY constraint failed}}
   } else {
     set expected [list 0 $res]
   }
   do_test fkey2-2.$tn [list catchsql $sql] $expected
   if {$nocommit} {
     do_test fkey2-2.${tn}c {
       catchsql COMMIT
-    } {1 {foreign key constraint failed}}
+    } {1 {FOREIGN KEY constraint failed}}
   }
 }
 
 fkey2-2-test 1 0 {
   CREATE TABLE node(
     nodeid PRIMARY KEY,
     parent REFERENCES node DEFERRABLE INITIALLY DEFERRED
   );
   CREATE TABLE leaf(
     cellid PRIMARY KEY,
@@ skipping 75 matching lines @@
 # had before the statement-transaction was opened.
 #
 fkey2-2-test 61 0 "BEGIN"
 fkey2-2-test 62 0   "DELETE FROM leaf"
 fkey2-2-test 63 0   "DELETE FROM node"
 fkey2-2-test 64 1   "INSERT INTO leaf VALUES('a', 1)"
 fkey2-2-test 65 1   "INSERT INTO leaf VALUES('b', 2)"
 fkey2-2-test 66 1   "INSERT INTO leaf VALUES('c', 1)"
 do_test fkey2-2-test-67 {
   catchsql          "INSERT INTO node SELECT parent, 3 FROM leaf"
-} {1 {column nodeid is not unique}}
+} {1 {UNIQUE constraint failed: node.nodeid}}
 fkey2-2-test 68 0 "COMMIT"           FKV
 fkey2-2-test 69 1   "INSERT INTO node VALUES(1, NULL)"
 fkey2-2-test 70 0   "INSERT INTO node VALUES(2, NULL)"
 fkey2-2-test 71 0 "COMMIT"
 
 fkey2-2-test 72 0 "BEGIN"
 fkey2-2-test 73 1   "DELETE FROM node"
 fkey2-2-test 74 0   "INSERT INTO node(nodeid) SELECT DISTINCT parent FROM leaf"
 fkey2-2-test 75 0 "COMMIT"
 
@@ skipping 21 matching lines @@
 } {}
 do_test fkey2-3.1.2 {
   execsql {
     INSERT INTO ab VALUES(1, 'b');
     INSERT INTO cd VALUES(1, 'd');
     INSERT INTO ef VALUES(1, 'e');
   }
 } {}
 do_test fkey2-3.1.3 {
   catchsql { UPDATE ab SET a = 5 }
-} {1 {constraint failed}}
+} {1 {CHECK constraint failed: ef}}
 do_test fkey2-3.1.4 {
   execsql { SELECT * FROM ab }
 } {1 b}
 do_test fkey2-3.1.4 {
   execsql BEGIN;
   catchsql { UPDATE ab SET a = 5 }
-} {1 {constraint failed}}
+} {1 {CHECK constraint failed: ef}}
 do_test fkey2-3.1.5 {
   execsql COMMIT;
   execsql { SELECT * FROM ab; SELECT * FROM cd; SELECT * FROM ef }
 } {1 b 1 d 1 e}
 
 do_test fkey2-3.2.1 {
   execsql BEGIN;
   catchsql { DELETE FROM ab }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-3.2.2 {
   execsql COMMIT
   execsql { SELECT * FROM ab; SELECT * FROM cd; SELECT * FROM ef }
 } {1 b 1 d 1 e}
 
 #-------------------------------------------------------------------------
 # Test cases fkey2-4.* test that recursive foreign key actions 
 # (i.e. CASCADE) are allowed even if recursive triggers are disabled.
 #
 drop_all_tables
@@ skipping 101 matching lines @@
 # 
 drop_all_tables
 do_test fkey2-7.1 {
   execsql {
     CREATE TABLE t1(a PRIMARY KEY, b);
     CREATE TABLE t2(c INTEGER PRIMARY KEY REFERENCES t1, b);
   }
 } {}
 do_test fkey2-7.2 {
   catchsql { INSERT INTO t2 VALUES(1, 'A'); }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-7.3 {
   execsql { 
     INSERT INTO t1 VALUES(1, 2);
     INSERT INTO t1 VALUES(2, 3);
     INSERT INTO t2 VALUES(1, 'A');
   }
 } {}
 do_test fkey2-7.4 {
   execsql { UPDATE t2 SET c = 2 }
 } {}
 do_test fkey2-7.5 {
   catchsql { UPDATE t2 SET c = 3 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-7.6 {
   catchsql { DELETE FROM t1 WHERE a = 2 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-7.7 {
   execsql { DELETE FROM t1 WHERE a = 1 }
 } {}
 do_test fkey2-7.8 {
   catchsql { UPDATE t1 SET a = 3 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-7.9 {
   catchsql { UPDATE t2 SET rowid = 3 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 #-------------------------------------------------------------------------
 # Test that it is not possible to enable/disable FK support while a
 # transaction is open.
 # 
 drop_all_tables
 proc fkey2-8-test {tn zSql value} {
   do_test fkey-2.8.$tn.1 [list execsql $zSql] {}
   do_test fkey-2.8.$tn.2 { execsql "PRAGMA foreign_keys" } $value
 }
@@ skipping 44 matching lines @@
     UPDATE t2 SET d = 2;
     DELETE FROM t1 WHERE a = 1;
     SELECT * FROM t2;
   }
 } {1 2}
 do_test fkey2-9.1.4 {
   execsql { SELECT * FROM t1 }
 } {2 two}
 do_test fkey2-9.1.5 {
   catchsql { DELETE FROM t1 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 do_test fkey2-9.2.1 {
   execsql {
     CREATE TABLE pp(a, b, c, PRIMARY KEY(b, c));
     CREATE TABLE cc(d DEFAULT 3, e DEFAULT 1, f DEFAULT 2,
         FOREIGN KEY(f, d) REFERENCES pp 
         ON UPDATE SET DEFAULT 
         ON DELETE SET NULL
     );
     INSERT INTO pp VALUES(1, 2, 3);
@@ skipping 34 matching lines @@
   CREATE TABLE c(x REFERENCES p);
 } {
   CREATE TABLE p(a COLLATE binary, b);
   CREATE UNIQUE INDEX i ON p(a COLLATE nocase);
   CREATE TABLE c(x REFERENCES p(a));
 }] {
   drop_all_tables
   do_test fkey2-10.1.[incr tn] {
     execsql $zSql
     catchsql { INSERT INTO c DEFAULT VALUES }
-  } {1 {foreign key mismatch}}
+  } {/1 {foreign key mismatch - "c" referencing "."}/}
 }
 
 # "rowid" cannot be used as part of a child or parent key definition 
 # unless it happens to be the name of an explicitly declared column.
 #
 do_test fkey2-10.2.1 {
   drop_all_tables
   catchsql {
     CREATE TABLE t1(a PRIMARY KEY, b);
     CREATE TABLE t2(c, d, FOREIGN KEY(rowid) REFERENCES t1(a));
   }
 } {1 {unknown column "rowid" in foreign key definition}}
 do_test fkey2-10.2.2 {
   drop_all_tables
   catchsql {
     CREATE TABLE t1(a PRIMARY KEY, b);
     CREATE TABLE t2(rowid, d, FOREIGN KEY(rowid) REFERENCES t1(a));
   }
 } {0 {}}
 do_test fkey2-10.2.1 {
   drop_all_tables
   catchsql {
     CREATE TABLE t1(a, b);
     CREATE TABLE t2(c, d, FOREIGN KEY(c) REFERENCES t1(rowid));
     INSERT INTO t1(rowid, a, b) VALUES(1, 1, 1);
     INSERT INTO t2 VALUES(1, 1);
   }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "t2" referencing "t1"}}
 do_test fkey2-10.2.2 {
   drop_all_tables
   catchsql {
     CREATE TABLE t1(rowid PRIMARY KEY, b);
     CREATE TABLE t2(c, d, FOREIGN KEY(c) REFERENCES t1(rowid));
     INSERT INTO t1(rowid, b) VALUES(1, 1);
     INSERT INTO t2 VALUES(1, 1);
   }
 } {0 {}}
 
@@ skipping 31 matching lines @@
 } {}
 do_test fkey2-12.1.2 { 
   execsql "BEGIN"
   execsql "INSERT INTO t2 VALUES('two')"
 } {}
 do_test fkey2-12.1.3 { 
   execsql "UPDATE t1 SET b = 'four' WHERE b = 'one'"
 } {}
 do_test fkey2-12.1.4 { 
   catchsql "UPDATE t1 SET b = 'five' WHERE b = 'two'"
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-12.1.5 { 
   execsql "DELETE FROM t1 WHERE b = 'two'"
 } {}
 do_test fkey2-12.1.6 { 
   catchsql "COMMIT"
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-12.1.7 { 
   execsql {
     INSERT INTO t1 VALUES(2, 'two');
     COMMIT;
   }
 } {}
 
 drop_all_tables
 do_test fkey2-12.2.1 {
   execsql {
@@ skipping 21 matching lines @@
   }
 } {A B a b}
 do_test fkey2-12.2.3 {
   execsql {
     DROP TABLE t2;
     CREATE TABLE t2(y REFERENCES t1 ON DELETE RESTRICT);
     INSERT INTO t2 VALUES('a');
     INSERT INTO t2 VALUES('b');
   }
   catchsql { DELETE FROM t1 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-12.2.4 {
   execsql {
     SELECT * FROM t1;
     SELECT * FROM t2;
   }
 } {A B a b}
 
 drop_all_tables
 do_test fkey2-12.3.1 {
   execsql {
@@ skipping 17 matching lines @@
   execsql {
     INSERT INTO up(c34, c35) VALUES('yes', 'no');
     INSERT INTO down(c39, c38) VALUES('yes', 'no');
     UPDATE up SET c34 = 'possibly';
     SELECT c38, c39 FROM down;
     DELETE FROM down;
   }
 } {no possibly}
 do_test fkey2-12.3.3 {
   catchsql { INSERT INTO down(c39, c38) VALUES('yes', 'no') }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-12.3.4 {
   execsql { 
     INSERT INTO up(c34, c35) VALUES('yes', 'no');
     INSERT INTO down(c39, c38) VALUES('yes', 'no');
   }
   catchsql { DELETE FROM up WHERE c34 = 'yes' }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-12.3.5 {
   execsql { 
     DELETE FROM up WHERE c34 = 'possibly';
     SELECT c34, c35 FROM up;
     SELECT c39, c38 FROM down;
   }
 } {yes no yes no}
 
 #-------------------------------------------------------------------------
 # The following tests, fkey2-13.*, test that FK processing is performed
 # when rows are REPLACEd.
 #
 drop_all_tables
 do_test fkey2-13.1.1 {
   execsql {
     CREATE TABLE pp(a UNIQUE, b, c, PRIMARY KEY(b, c));
     CREATE TABLE cc(d, e, f UNIQUE, FOREIGN KEY(d, e) REFERENCES pp);
     INSERT INTO pp VALUES(1, 2, 3);
     INSERT INTO cc VALUES(2, 3, 1);
   }
 } {}
 foreach {tn stmt} {
   1   "REPLACE INTO pp VALUES(1, 4, 5)"
   2   "REPLACE INTO pp(rowid, a, b, c) VALUES(1, 2, 3, 4)"
 } {
   do_test fkey2-13.1.$tn.1 {
     catchsql $stmt
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-13.1.$tn.2 {
     execsql {
       SELECT * FROM pp;
       SELECT * FROM cc;
     }
   } {1 2 3 2 3 1}
   do_test fkey2-13.1.$tn.3 {
     execsql BEGIN;
     catchsql $stmt
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-13.1.$tn.4 {
     execsql {
       COMMIT;
       SELECT * FROM pp;
       SELECT * FROM cc;
     }
   } {1 2 3 2 3 1}
 }
 do_test fkey2-13.1.3 {
   execsql { 
@@ skipping 83 matching lines @@
   do_test fkey2-14.2.2.2 {
     execsql { ALTER TABLE t1 RENAME TO t4 }
     execsql { SELECT sql FROM sqlite_master WHERE type = 'table'}
   } [list \
     {CREATE TABLE "t4"(a PRIMARY KEY, b REFERENCES "t4")}                    \
     {CREATE TABLE t2(a PRIMARY KEY, b REFERENCES "t4", c REFERENCES t2)}     \
     {CREATE TABLE t3(a REFERENCES "t4", b REFERENCES t2, c REFERENCES "t4")} \
   ]
   do_test fkey2-14.2.2.3 {
     catchsql { INSERT INTO t3 VALUES(1, 2, 3) }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-14.2.2.4 {
     execsql { INSERT INTO t4 VALUES(1, NULL) }
   } {}
   do_test fkey2-14.2.2.5 {
     catchsql { UPDATE t4 SET b = 5 }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-14.2.2.6 {
     catchsql { UPDATE t4 SET b = 1 }
   } {0 {}}
   do_test fkey2-14.2.2.7 {
     execsql { INSERT INTO t3 VALUES(1, NULL, 1) }
   } {}
 
   # Repeat for TEMP tables
   #
   drop_all_tables
@@ skipping 54 matching lines @@
   do_test fkey2-14.2tmp.2.2 {
     execsql { ALTER TABLE t1 RENAME TO t4 }
     execsql { SELECT sql FROM sqlite_temp_master WHERE type = 'table'}
   } [list \
     {CREATE TABLE "t4"(a PRIMARY KEY, b REFERENCES "t4")}                    \
     {CREATE TABLE t2(a PRIMARY KEY, b REFERENCES "t4", c REFERENCES t2)}     \
     {CREATE TABLE t3(a REFERENCES "t4", b REFERENCES t2, c REFERENCES "t4")} \
   ]
   do_test fkey2-14.2tmp.2.3 {
     catchsql { INSERT INTO t3 VALUES(1, 2, 3) }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-14.2tmp.2.4 {
     execsql { INSERT INTO t4 VALUES(1, NULL) }
   } {}
   do_test fkey2-14.2tmp.2.5 {
     catchsql { UPDATE t4 SET b = 5 }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-14.2tmp.2.6 {
     catchsql { UPDATE t4 SET b = 1 }
   } {0 {}}
   do_test fkey2-14.2tmp.2.7 {
     execsql { INSERT INTO t3 VALUES(1, NULL, 1) }
   } {}
 
   # Repeat for ATTACH-ed tables
   #
   drop_all_tables
@@ skipping 55 matching lines @@
   do_test fkey2-14.2aux.2.2 {
     execsql { ALTER TABLE t1 RENAME TO t4 }
     execsql { SELECT sql FROM aux.sqlite_master WHERE type = 'table'}
   } [list \
     {CREATE TABLE "t4"(a PRIMARY KEY, b REFERENCES "t4")}                    \
     {CREATE TABLE t2(a PRIMARY KEY, b REFERENCES "t4", c REFERENCES t2)}     \
     {CREATE TABLE t3(a REFERENCES "t4", b REFERENCES t2, c REFERENCES "t4")} \
   ]
   do_test fkey2-14.2aux.2.3 {
     catchsql { INSERT INTO t3 VALUES(1, 2, 3) }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-14.2aux.2.4 {
     execsql { INSERT INTO t4 VALUES(1, NULL) }
   } {}
   do_test fkey2-14.2aux.2.5 {
     catchsql { UPDATE t4 SET b = 5 }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-14.2aux.2.6 {
     catchsql { UPDATE t4 SET b = 1 }
   } {0 {}}
   do_test fkey2-14.2aux.2.7 {
     execsql { INSERT INTO t3 VALUES(1, NULL, 1) }
   } {}
 }
 
 do_test fkey-2.14.3.1 {
   drop_all_tables
   execsql {
     CREATE TABLE t1(a, b REFERENCES nosuchtable);
     DROP TABLE t1;
   }
 } {}
 do_test fkey-2.14.3.2 {
   execsql {
     CREATE TABLE t1(a PRIMARY KEY, b);
     INSERT INTO t1 VALUES('a', 1);
     CREATE TABLE t2(x REFERENCES t1);
     INSERT INTO t2 VALUES('a');
   }
 } {}
 do_test fkey-2.14.3.3 {
   catchsql { DROP TABLE t1 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey-2.14.3.4 {
   execsql {
     DELETE FROM t2;
     DROP TABLE t1;
   }
 } {}
 do_test fkey-2.14.3.4 {
   catchsql { INSERT INTO t2 VALUES('x') }
 } {1 {no such table: main.t1}}
 do_test fkey-2.14.3.5 {
   execsql {
     CREATE TABLE t1(x PRIMARY KEY);
     INSERT INTO t1 VALUES('x');
   }
   execsql { INSERT INTO t2 VALUES('x') }
 } {}
 do_test fkey-2.14.3.6 {
   catchsql { DROP TABLE t1 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey-2.14.3.7 {
   execsql {
     DROP TABLE t2;
     DROP TABLE t1;
   }
 } {}
 do_test fkey-2.14.3.8 {
   execsql {
     CREATE TABLE pp(x, y, PRIMARY KEY(x, y));
     CREATE TABLE cc(a, b, FOREIGN KEY(a, b) REFERENCES pp(x, z));
   }
   catchsql { INSERT INTO cc VALUES(1, 2) }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "cc" referencing "pp"}}
 do_test fkey-2.14.3.9 {
   execsql { DROP TABLE cc }
 } {}
 do_test fkey-2.14.3.10 {
   execsql {
     CREATE TABLE cc(a, b, 
       FOREIGN KEY(a, b) REFERENCES pp DEFERRABLE INITIALLY DEFERRED
     );
   }
   execsql {
@@ skipping 124 matching lines @@
   do_test fkey2-16.1.$tn.1 {
     execsql $zSchema
     execsql { INSERT INTO self VALUES(13, 13) }
   } {}
   do_test fkey2-16.1.$tn.2 {
     execsql { UPDATE self SET a = 14, b = 14 }
   } {}
 
   do_test fkey2-16.1.$tn.3 {
     catchsql { UPDATE self SET b = 15 }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
 
   do_test fkey2-16.1.$tn.4 {
     catchsql { UPDATE self SET a = 15 }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
 
   do_test fkey2-16.1.$tn.5 {
     catchsql { UPDATE self SET a = 15, b = 16 }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
 
   do_test fkey2-16.1.$tn.6 {
     catchsql { UPDATE self SET a = 17, b = 17 }
   } {0 {}}
 
   do_test fkey2-16.1.$tn.7 {
     execsql { DELETE FROM self }
   } {}
   do_test fkey2-16.1.$tn.8 {
     catchsql { INSERT INTO self VALUES(20, 21) }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
 }
 
 #-------------------------------------------------------------------------
 # This next block of tests, fkey2-17.*, tests that if "PRAGMA count_changes"
 # is turned on statements that violate immediate FK constraints return
 # SQLITE_CONSTRAINT immediately, not after returning a number of rows.
 # Whereas statements that violate deferred FK constraints return the number
 # of rows before failing.
 #
 # Also test that rows modified by FK actions are not counted in either the
 # returned row count or the values returned by sqlite3_changes(). Like
 # trigger related changes, they are included in sqlite3_total_changes() though.
 #
 drop_all_tables
 do_test fkey2-17.1.1 {
   execsql { PRAGMA count_changes = 1 }
   execsql { 
     CREATE TABLE one(a, b, c, UNIQUE(b, c));
     CREATE TABLE two(d, e, f, FOREIGN KEY(e, f) REFERENCES one(b, c));
     INSERT INTO one VALUES(1, 2, 3);
   }
 } {1}
 do_test fkey2-17.1.2 {
   set STMT [sqlite3_prepare_v2 db "INSERT INTO two VALUES(4, 5, 6)" -1 dummy]
   sqlite3_step $STMT
 } {SQLITE_CONSTRAINT}
+verify_ex_errcode fkey2-17.1.2b SQLITE_CONSTRAINT_FOREIGNKEY
 ifcapable autoreset {
   do_test fkey2-17.1.3 {
     sqlite3_step $STMT
   } {SQLITE_CONSTRAINT}
+  verify_ex_errcode fkey2-17.1.3b SQLITE_CONSTRAINT_FOREIGNKEY
 } else {
   do_test fkey2-17.1.3 {
     sqlite3_step $STMT
   } {SQLITE_MISUSE}
 }
 do_test fkey2-17.1.4 {
   sqlite3_finalize $STMT
 } {SQLITE_CONSTRAINT}
+verify_ex_errcode fkey2-17.1.4b SQLITE_CONSTRAINT_FOREIGNKEY
 do_test fkey2-17.1.5 {
   execsql {
     INSERT INTO one VALUES(2, 3, 4);
     INSERT INTO one VALUES(3, 4, 5);
     INSERT INTO two VALUES(1, 2, 3);
     INSERT INTO two VALUES(2, 3, 4);
     INSERT INTO two VALUES(3, 4, 5);
   }
 } {1 1 1 1 1}
 do_test fkey2-17.1.6 {
   catchsql {
     BEGIN;
       INSERT INTO one VALUES(0, 0, 0);
       UPDATE two SET e=e+1, f=f+1;
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-17.1.7 {
   execsql { SELECT * FROM one }
 } {1 2 3 2 3 4 3 4 5 0 0 0}
 do_test fkey2-17.1.8 {
   execsql { SELECT * FROM two }
 } {1 2 3 2 3 4 3 4 5}
 do_test fkey2-17.1.9 {
   execsql COMMIT
 } {}
 do_test fkey2-17.1.10 {
   execsql {
     CREATE TABLE three(
       g, h, i, 
       FOREIGN KEY(h, i) REFERENCES one(b, c) DEFERRABLE INITIALLY DEFERRED
     );
   }
 } {}
 do_test fkey2-17.1.11 {
   set STMT [sqlite3_prepare_v2 db "INSERT INTO three VALUES(7, 8, 9)" -1 dummy]
   sqlite3_step $STMT
 } {SQLITE_ROW}
 do_test fkey2-17.1.12 {
   sqlite3_column_text $STMT 0
 } {1}
 do_test fkey2-17.1.13 {
   sqlite3_step $STMT
 } {SQLITE_CONSTRAINT}
+verify_ex_errcode fkey2-17.1.13b SQLITE_CONSTRAINT_FOREIGNKEY
 do_test fkey2-17.1.14 {
   sqlite3_finalize $STMT
 } {SQLITE_CONSTRAINT}
+verify_ex_errcode fkey2-17.1.14b SQLITE_CONSTRAINT_FOREIGNKEY
 
 drop_all_tables
 do_test fkey2-17.2.1 {
   execsql {
     CREATE TABLE high("a'b!" PRIMARY KEY, b);
     CREATE TABLE low(
       c, 
       "d&6" REFERENCES high ON UPDATE CASCADE ON DELETE CASCADE
     );
   }
@@ skipping 38 matching lines @@
 
 ifcapable auth {
   do_test fkey2-18.1 {
     execsql {
       CREATE TABLE long(a, b PRIMARY KEY, c);
       CREATE TABLE short(d, e, f REFERENCES long);
       CREATE TABLE mid(g, h, i REFERENCES long DEFERRABLE INITIALLY DEFERRED);
     }
   } {}
 
-  proc auth {args} {eval lappend ::authargs $args ; return SQLITE_OK}
+  proc auth {args} {eval lappend ::authargs [lrange $args 0 4]; return SQLITE_OK}
   db auth auth
 
   # An insert on the parent table must read the child key of any deferred
   # foreign key constraints. But not the child key of immediate constraints.
   set authargs {}
   do_test fkey2-18.2 {
     execsql { INSERT INTO long VALUES(1, 2, 3) }
     set authargs
   } {SQLITE_INSERT long {} main {} SQLITE_READ mid i main {}}
 
@@ skipping 44 matching lines @@
   # Return SQLITE_IGNORE to requests to read from the parent table. This
   # causes inserts of non-NULL keys into the child table to fail.
   #
   rename auth {}
   proc auth {args} {
     if {[lindex $args 1] == "long"} {return SQLITE_IGNORE}
     return SQLITE_OK
   }
   do_test fkey2-18.8 {
     catchsql { INSERT INTO short VALUES(1, 3, 2) }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-18.9 {
     execsql { INSERT INTO short VALUES(1, 3, NULL) }
   } {}
   do_test fkey2-18.10 {
     execsql { SELECT * FROM short }
   } {1 3 2 1 3 {}}
   do_test fkey2-18.11 {
     catchsql { UPDATE short SET f = 2 WHERE f IS NULL }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
 
   db auth {}
   unset authargs
 }
 
 
 do_test fkey2-19.1 {
   execsql {
     CREATE TABLE main(id INTEGER PRIMARY KEY);
     CREATE TABLE sub(id INT REFERENCES main(id));
     INSERT INTO main VALUES(1);
     INSERT INTO main VALUES(2);
     INSERT INTO sub VALUES(2);
   }
 } {}
 do_test fkey2-19.2 {
   set S [sqlite3_prepare_v2 db "DELETE FROM main WHERE id = ?" -1 dummy]
   sqlite3_bind_int $S 1 2
   sqlite3_step $S
 } {SQLITE_CONSTRAINT}
+verify_ex_errcode fkey2-19.2b SQLITE_CONSTRAINT_FOREIGNKEY
 do_test fkey2-19.3 {
   sqlite3_reset $S
 } {SQLITE_CONSTRAINT}
+verify_ex_errcode fkey2-19.3b SQLITE_CONSTRAINT_FOREIGNKEY
 do_test fkey2-19.4 {
   sqlite3_bind_int $S 1 1
   sqlite3_step $S
 } {SQLITE_DONE}
 do_test fkey2-19.4 {
   sqlite3_finalize $S
 } {SQLITE_OK}
 
 drop_all_tables
 do_test fkey2-20.1 {
   execsql {
     CREATE TABLE pp(a PRIMARY KEY, b);
     CREATE TABLE cc(c PRIMARY KEY, d REFERENCES pp);
   }
 } {}
 
 foreach {tn insert} {
   1 "INSERT"
   2 "INSERT OR IGNORE"
   3 "INSERT OR ABORT"
   4 "INSERT OR ROLLBACK"
   5 "INSERT OR REPLACE"
   6 "INSERT OR FAIL"
 } {
   do_test fkey2-20.2.$tn.1 {
     catchsql "$insert INTO cc VALUES(1, 2)"
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-20.2.$tn.2 {
     execsql { SELECT * FROM cc }
   } {}
   do_test fkey2-20.2.$tn.3 {
     execsql {
       BEGIN;
         INSERT INTO pp VALUES(2, 'two');
         INSERT INTO cc VALUES(1, 2);
     }
     catchsql "$insert INTO cc VALUES(3, 4)"
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-20.2.$tn.4 {
     execsql { COMMIT ; SELECT * FROM cc }
   } {1 2}
   do_test fkey2-20.2.$tn.5 {
     execsql { DELETE FROM cc ; DELETE FROM pp }
   } {}
 }
 
 foreach {tn update} {
   1 "UPDATE"
   2 "UPDATE OR IGNORE"
   3 "UPDATE OR ABORT"
   4 "UPDATE OR ROLLBACK"
   5 "UPDATE OR REPLACE"
   6 "UPDATE OR FAIL"
 } {
   do_test fkey2-20.3.$tn.1 {
     execsql {
       INSERT INTO pp VALUES(2, 'two');
       INSERT INTO cc VALUES(1, 2);
     }
   } {}
   do_test fkey2-20.3.$tn.2 {
     catchsql "$update pp SET a = 1"
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-20.3.$tn.3 {
     execsql { SELECT * FROM pp }
   } {2 two}
   do_test fkey2-20.3.$tn.4 {
     catchsql "$update cc SET d = 1"
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-20.3.$tn.5 {
     execsql { SELECT * FROM cc }
   } {1 2}
   do_test fkey2-20.3.$tn.6 {
     execsql {
       BEGIN;
         INSERT INTO pp VALUES(3, 'three');
     }
     catchsql "$update pp SET a = 1 WHERE a = 2"
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-20.3.$tn.7 {
     execsql { COMMIT ; SELECT * FROM pp }
   } {2 two 3 three}
   do_test fkey2-20.3.$tn.8 {
     execsql {
       BEGIN;
         INSERT INTO cc VALUES(2, 2);
     }
     catchsql "$update cc SET d = 1 WHERE c = 1"
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
   do_test fkey2-20.3.$tn.9 {
     execsql { COMMIT ; SELECT * FROM cc }
   } {1 2 2 2}
   do_test fkey2-20.3.$tn.10 {
     execsql { DELETE FROM cc ; DELETE FROM pp }
   } {}
 }
 
 #-------------------------------------------------------------------------
 # The following block of tests, those prefixed with "fkey2-genfkey.", are 
 # the same tests that were used to test the ".genfkey" command provided 
 # by the shell tool. So these tests show that the built-in foreign key 
 # implementation is more or less compatible with the triggers generated 
 # by genfkey.
 #
 drop_all_tables
 do_test fkey2-genfkey.1.1 {
   execsql {
     CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, UNIQUE(b, c));
     CREATE TABLE t2(e REFERENCES t1, f);
     CREATE TABLE t3(g, h, i, FOREIGN KEY (h, i) REFERENCES t1(b, c));
   }
 } {}
 do_test fkey2-genfkey.1.2 {
   catchsql { INSERT INTO t2 VALUES(1, 2) }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-genfkey.1.3 {
   execsql {
     INSERT INTO t1 VALUES(1, 2, 3);
     INSERT INTO t2 VALUES(1, 2);
   }
 } {}
 do_test fkey2-genfkey.1.4 {
   execsql { INSERT INTO t2 VALUES(NULL, 3) }
 } {}
 do_test fkey2-genfkey.1.5 {
   catchsql { UPDATE t2 SET e = 5 WHERE e IS NULL }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-genfkey.1.6 {
   execsql { UPDATE t2 SET e = 1 WHERE e IS NULL }
 } {}
 do_test fkey2-genfkey.1.7 {
   execsql { UPDATE t2 SET e = NULL WHERE f = 3 }
 } {}
 do_test fkey2-genfkey.1.8 {
   catchsql { UPDATE t1 SET a = 10 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-genfkey.1.9 {
   catchsql { UPDATE t1 SET a = NULL }
 } {1 {datatype mismatch}}
 do_test fkey2-genfkey.1.10 {
   catchsql { DELETE FROM t1 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-genfkey.1.11 {
   execsql { UPDATE t2 SET e = NULL }
 } {}
 do_test fkey2-genfkey.1.12 {
   execsql { 
     UPDATE t1 SET a = 10;
     DELETE FROM t1;
     DELETE FROM t2;
   }
 } {}
 do_test fkey2-genfkey.1.13 {
   execsql {
     INSERT INTO t3 VALUES(1, NULL, NULL);
     INSERT INTO t3 VALUES(1, 2, NULL);
     INSERT INTO t3 VALUES(1, NULL, 3);
   }
 } {}
 do_test fkey2-genfkey.1.14 {
   catchsql { INSERT INTO t3 VALUES(3, 1, 4) }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-genfkey.1.15 {
   execsql { 
     INSERT INTO t1 VALUES(1, 1, 4);
     INSERT INTO t3 VALUES(3, 1, 4);
   }
 } {}
 do_test fkey2-genfkey.1.16 {
   catchsql { DELETE FROM t1 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-genfkey.1.17 {
   catchsql { UPDATE t1 SET b = 10}
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-genfkey.1.18 {
   execsql { UPDATE t1 SET a = 10}
 } {}
 do_test fkey2-genfkey.1.19 {
   catchsql { UPDATE t3 SET h = 'hello' WHERE i = 3}
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 drop_all_tables
 do_test fkey2-genfkey.2.1 {
   execsql {
     CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, UNIQUE(b, c));
     CREATE TABLE t2(e REFERENCES t1 ON UPDATE CASCADE ON DELETE CASCADE, f);
     CREATE TABLE t3(g, h, i, 
         FOREIGN KEY (h, i) 
         REFERENCES t1(b, c) ON UPDATE CASCADE ON DELETE CASCADE
     );
@@ skipping 92 matching lines @@
     INSERT INTO tdd08 VALUES(200,300);
 
     CREATE TABLE tdd08_b(w,x,y, FOREIGN KEY(x,y) REFERENCES tdd08(a,b));
     INSERT INTO tdd08_b VALUES(100,200,300);
   }
 } {}
 do_test fkey2-dd08e5.1.2 {
   catchsql {
     DELETE FROM tdd08;
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-dd08e5.1.3 {
   execsql {
     SELECT * FROM tdd08;
   }
 } {200 300}
 do_test fkey2-dd08e5.1.4 {
   catchsql {
     INSERT INTO tdd08_b VALUES(400,500,300);
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-dd08e5.1.5 {
   catchsql {
     UPDATE tdd08_b SET x=x+1;
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-dd08e5.1.6 {
   catchsql {
     UPDATE tdd08 SET a=a+1;
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 #-------------------------------------------------------------------------
 # Verify that ticket ce7c133ea6cc9ccdc1a60d80441f80b6180f5eba
 # fixed.
 #
 do_test fkey2-ce7c13.1.1 {
   execsql {
     CREATE TABLE tce71(a INTEGER PRIMARY KEY, b);
     CREATE UNIQUE INDEX ice71 ON tce71(a,b);
     INSERT INTO tce71 VALUES(100,200);
     CREATE TABLE tce72(w, x, y, FOREIGN KEY(x,y) REFERENCES tce71(a,b));
     INSERT INTO tce72 VALUES(300,100,200);
     UPDATE tce71 set b = 200 where a = 100;
     SELECT * FROM tce71, tce72;
   }
 } {100 200 300 100 200}
 do_test fkey2-ce7c13.1.2 {
   catchsql {
     UPDATE tce71 set b = 201 where a = 100;
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-ce7c13.1.3 {
   catchsql {
     UPDATE tce71 set a = 101 where a = 100;
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-ce7c13.1.4 {
   execsql {
     CREATE TABLE tce73(a INTEGER PRIMARY KEY, b, UNIQUE(a,b));
     INSERT INTO tce73 VALUES(100,200);
     CREATE TABLE tce74(w, x, y, FOREIGN KEY(x,y) REFERENCES tce73(a,b));
     INSERT INTO tce74 VALUES(300,100,200);
     UPDATE tce73 set b = 200 where a = 100;
     SELECT * FROM tce73, tce74;
   }
 } {100 200 300 100 200}
 do_test fkey2-ce7c13.1.5 {
   catchsql {
     UPDATE tce73 set b = 201 where a = 100;
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test fkey2-ce7c13.1.6 {
   catchsql {
     UPDATE tce73 set a = 101 where a = 100;
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 finish_test