Import SQLite 3.8.7.4.

third_party/sqlite/src/test/e_fkey.test

 # 2009 October 7
 #
 # 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 117 matching lines @@
 reset_db
 
 
 #-------------------------------------------------------------------------
 # EVIDENCE-OF: R-07280-60510 Assuming the library is compiled with
 # foreign key constraints enabled, it must still be enabled by the
 # application at runtime, using the PRAGMA foreign_keys command.
 #
 # This also tests that foreign key constraints are disabled by default.
 #
-# EVIDENCE-OF: R-59578-04990 Foreign key constraints are disabled by
+# EVIDENCE-OF: R-44261-39702 Foreign key constraints are disabled by
 # default (for backwards compatibility), so must be enabled separately
-# for each database connection separately.
+# for each database connection.
 #
 drop_all_tables
 do_test e_fkey-4.1 {
   execsql {
     CREATE TABLE p(i PRIMARY KEY);
     CREATE TABLE c(j REFERENCES p ON UPDATE CASCADE);
     INSERT INTO p VALUES('hello');
     INSERT INTO c VALUES('hello');
     UPDATE p SET i = 'world';
     SELECT * FROM c;
   } 
 } {hello}
 do_test e_fkey-4.2 {
   execsql {
     DELETE FROM c;
     DELETE FROM p;
     PRAGMA foreign_keys = ON;
     INSERT INTO p VALUES('hello');
     INSERT INTO c VALUES('hello');
     UPDATE p SET i = 'world';
     SELECT * FROM c;
   } 
 } {world}
 
 #-------------------------------------------------------------------------
-# EVIDENCE-OF: R-15278-54456 The application can can also use a PRAGMA
+# EVIDENCE-OF: R-08013-37737 The application can also use a PRAGMA
 # foreign_keys statement to determine if foreign keys are currently
 # enabled.
+
 #
 # This also tests the example code in section 2 of foreignkeys.in.
 #
 # EVIDENCE-OF: R-11255-19907
 # 
 reset_db
 do_test e_fkey-5.1 {
   execsql { PRAGMA foreign_keys }
 } {0}
 do_test e_fkey-5.2 {
@@ skipping 25 matching lines @@
     CREATE TABLE t1(a UNIQUE, b);
     CREATE TABLE t2(c, d REFERENCES t1(a));
     INSERT INTO t1 VALUES(1, 2);
     INSERT INTO t2 VALUES(2, 1);
     BEGIN;
       PRAGMA foreign_keys = OFF;
   }
   catchsql {
       DELETE FROM t1
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-6.2 {
   execsql { PRAGMA foreign_keys }
 } {1}
 do_test e_fkey-6.3 {
   execsql {
     COMMIT;
     PRAGMA foreign_keys = OFF;
     BEGIN;
       PRAGMA foreign_keys = ON;
       DELETE FROM t1;
@@ skipping 33 matching lines @@
   }
 } {}
 
 #-------------------------------------------------------------------------
 # EVIDENCE-OF: R-61362-32087 Attempting to insert a row into the track
 # table that does not correspond to any row in the artist table will
 # fail,
 #
 do_test e_fkey-8.1 {
   catchsql { INSERT INTO track VALUES(1, 'track 1', 1) }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-8.2 {
   execsql { INSERT INTO artist VALUES(2, 'artist 1') }
   catchsql { INSERT INTO track VALUES(1, 'track 1', 1) }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-8.2 {
   execsql { INSERT INTO track VALUES(1, 'track 1', 2) }
 } {}
 
 #-------------------------------------------------------------------------
 # Attempting to delete a row from the 'artist' table while there are 
 # dependent rows in the track table also fails.
 #
 # EVIDENCE-OF: R-24401-52400 as will attempting to delete a row from the
 # artist table when there exist dependent rows in the track table
 #
 do_test e_fkey-9.1 {
   catchsql { DELETE FROM artist WHERE artistid = 2 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-9.2 {
   execsql { 
     DELETE FROM track WHERE trackartist = 2;
     DELETE FROM artist WHERE artistid = 2;
   }
 } {}
 
 #-------------------------------------------------------------------------
 # If the foreign key column (trackartist) in table 'track' is set to NULL,
 # there is no requirement for a matching row in the 'artist' table.
 #
 # EVIDENCE-OF: R-23980-48859 There is one exception: if the foreign key
 # column in the track table is NULL, then no corresponding entry in the
 # artist table is required.
 #
 do_test e_fkey-10.1 {
   execsql {
     INSERT INTO track VALUES(1, 'track 1', NULL);
     INSERT INTO track VALUES(2, 'track 2', NULL);
   }
 } {}
 do_test e_fkey-10.2 {
   execsql { SELECT * FROM artist }
 } {}
 do_test e_fkey-10.3 {
   # Setting the trackid to a non-NULL value fails, of course.
   catchsql { UPDATE track SET trackartist = 5 WHERE trackid = 1 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-10.4 {
   execsql {
     INSERT INTO artist VALUES(5, 'artist 5');
     UPDATE track SET trackartist = 5 WHERE trackid = 1;
   }
   catchsql { DELETE FROM artist WHERE artistid = 5}
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-10.5 {
   execsql { 
     UPDATE track SET trackartist = NULL WHERE trackid = 1;
     DELETE FROM artist WHERE artistid = 5;
   }
 } {}
 
 #-------------------------------------------------------------------------
 # Test that the following is true fo all rows in the track table:
 #
 #   trackartist IS NULL OR 
 #   EXISTS(SELECT 1 FROM artist WHERE artistid=trackartist)
 #
 # EVIDENCE-OF: R-52486-21352 Expressed in SQL, this means that for every
 # row in the track table, the following expression evaluates to true:
 # trackartist IS NULL OR EXISTS(SELECT 1 FROM artist WHERE
 # artistid=trackartist)
 
 # This procedure executes a test case to check that statement 
 # R-52486-21352 is true after executing the SQL statement passed.
 # as the second argument.
 proc test_r52486_21352 {tn sql} {
   set res [catchsql $sql]
   set results {
     {0 {}} 
-    {1 {PRIMARY KEY must be unique}} 
-    {1 {foreign key constraint failed}}
+    {1 {UNIQUE constraint failed: artist.artistid}} 
+    {1 {FOREIGN KEY constraint failed}}
   }
   if {[lsearch $results $res]<0} {
     error $res
   }
 
   do_test e_fkey-11.$tn {
     execsql {
       SELECT count(*) FROM track WHERE NOT (
         trackartist IS NULL OR 
         EXISTS(SELECT 1 FROM artist WHERE artistid=trackartist)
@@ skipping 43 matching lines @@
     CREATE TABLE track(
       trackid     INTEGER, 
       trackname   TEXT, 
       trackartist INTEGER NOT NULL,
       FOREIGN KEY(trackartist) REFERENCES artist(artistid)
     );
   }
 } {}
 do_test e_fkey-12.2 {
   catchsql { INSERT INTO track VALUES(14, 'Mr. Bojangles', NULL) }
-} {1 {track.trackartist may not be NULL}}
+} {1 {NOT NULL constraint failed: track.trackartist}}
 
 #-------------------------------------------------------------------------
 # EVIDENCE-OF: R-16127-35442
 #
 # Test an example from foreignkeys.html.
 #
 drop_all_tables
 do_test e_fkey-13.1 {
   execsql {
     CREATE TABLE artist(
       artistid    INTEGER PRIMARY KEY, 
       artistname  TEXT
     );
     CREATE TABLE track(
       trackid     INTEGER, 
       trackname   TEXT, 
       trackartist INTEGER,
       FOREIGN KEY(trackartist) REFERENCES artist(artistid)
     );
     INSERT INTO artist VALUES(1, 'Dean Martin');
     INSERT INTO artist VALUES(2, 'Frank Sinatra');
     INSERT INTO track VALUES(11, 'That''s Amore', 1);
     INSERT INTO track VALUES(12, 'Christmas Blues', 1);
     INSERT INTO track VALUES(13, 'My Way', 2);
   }
 } {}
 do_test e_fkey-13.2 {
   catchsql { INSERT INTO track VALUES(14, 'Mr. Bojangles', 3) }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-13.3 {
   execsql { INSERT INTO track VALUES(14, 'Mr. Bojangles', NULL) }
 } {}
 do_test e_fkey-13.4 {
   catchsql { 
     UPDATE track SET trackartist = 3 WHERE trackname = 'Mr. Bojangles';
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-13.5 {
   execsql {
     INSERT INTO artist VALUES(3, 'Sammy Davis Jr.');
     UPDATE track SET trackartist = 3 WHERE trackname = 'Mr. Bojangles';
     INSERT INTO track VALUES(15, 'Boogie Woogie', 3);
   }
 } {}
 
 #-------------------------------------------------------------------------
 # EVIDENCE-OF: R-15958-50233
 #
 # Test the second example from the first section of foreignkeys.html.
 #
 do_test e_fkey-14.1 {
   catchsql {
     DELETE FROM artist WHERE artistname = 'Frank Sinatra';
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-14.2 {
   execsql {
     DELETE FROM track WHERE trackname = 'My Way';
     DELETE FROM artist WHERE artistname = 'Frank Sinatra';
   }
 } {}
 do_test e_fkey-14.3 {
   catchsql {
     UPDATE artist SET artistid=4 WHERE artistname = 'Dean Martin';
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-14.4 {
   execsql {
     DELETE FROM track WHERE trackname IN('That''s Amore', 'Christmas Blues');
     UPDATE artist SET artistid=4 WHERE artistname = 'Dean Martin';
   }
 } {}
 
 
 #-------------------------------------------------------------------------
 # EVIDENCE-OF: R-56032-24923 The foreign key constraint is satisfied if
@@ skipping 17 matching lines @@
     INSERT INTO par VALUES(1);
     INSERT INTO par VALUES('1');
     INSERT INTO par VALUES(X'31');
     SELECT typeof(p) FROM par;
   }
 } {integer text blob}
 
 proc test_efkey_45 {tn isError sql} {
   do_test e_fkey-15.$tn.1 "
     catchsql {$sql}
-  " [lindex {{0 {}} {1 {foreign key constraint failed}}} $isError]
+  " [lindex {{0 {}} {1 {FOREIGN KEY constraint failed}}} $isError]
 
   do_test e_fkey-15.$tn.2 {
     execsql {
       SELECT * FROM chi WHERE c IS NOT NULL AND c NOT IN (SELECT p FROM par)
     }
   } {}
 }
 
 test_efkey_45 1 0 "INSERT INTO chi VALUES(1)"
 test_efkey_45 2 1 "INSERT INTO chi VALUES('1.0')"
@@ skipping 23 matching lines @@
   execsql {
     INSERT INTO t1 VALUES('oNe');
     INSERT INTO t2 VALUES('one');
     INSERT INTO t2 VALUES('ONE');
     UPDATE t2 SET b = 'OnE';
     UPDATE t1 SET a = 'ONE';
   }
 } {}
 do_test e_fkey-16.3 {
   catchsql { UPDATE t2 SET b = 'two' WHERE rowid = 1 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-16.4 {
   catchsql { DELETE FROM t1 WHERE rowid = 1 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 #-------------------------------------------------------------------------
 # Specifically, test that when comparing child and parent key values the
 # affinity of the parent key column is applied to the child key value
 # before the comparison takes place.
 #
 # EVIDENCE-OF: R-04240-13860 When comparing values, if the parent key
 # column has an affinity, then that affinity is applied to the child key
 # value before the comparison is performed.
 #
@@ skipping 11 matching lines @@
     INSERT INTO t1 VALUES('three');
     INSERT INTO t2 VALUES('2.0');
     SELECT b, typeof(b) FROM t2;
   }
 } {2.0 text}
 do_test e_fkey-17.3 {
   execsql { SELECT typeof(a) FROM t1 }
 } {integer integer text}
 do_test e_fkey-17.4 {
   catchsql { DELETE FROM t1 WHERE rowid = 2 }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 ###########################################################################
 ### SECTION 3: Required and Suggested Database Indexes
 ###########################################################################
 
 #-------------------------------------------------------------------------
 # A parent key must be either a PRIMARY KEY, subject to a UNIQUE 
 # constraint, or have a UNIQUE index created on it.
 #
 # EVIDENCE-OF: R-13435-26311 Usually, the parent key of a foreign key
@@ skipping 14 matching lines @@
 do_test e_fkey-18.1 {
   execsql {
     CREATE TABLE t2(a REFERENCES t1(x));
   }
 } {}
 proc test_efkey_57 {tn isError sql} {
   catchsql { DROP TABLE t1 }
   execsql $sql
   do_test e_fkey-18.$tn {
     catchsql { INSERT INTO t2 VALUES(NULL) }
-  } [lindex {{0 {}} {1 {foreign key mismatch}}} $isError]
+  } [lindex {{0 {}} {/1 {foreign key mismatch - ".*" referencing ".*"}/}} \
+     $isError]
 }
 test_efkey_57 2 0 { CREATE TABLE t1(x PRIMARY KEY) }
 test_efkey_57 3 0 { CREATE TABLE t1(x UNIQUE) }
 test_efkey_57 4 0 { CREATE TABLE t1(x); CREATE UNIQUE INDEX t1i ON t1(x) }
 test_efkey_57 5 1 { 
   CREATE TABLE t1(x); 
   CREATE UNIQUE INDEX t1i ON t1(x COLLATE nocase);
 }
 test_efkey_57 6 1 { CREATE TABLE t1(x) }
 test_efkey_57 7 1 { CREATE TABLE t1(x, y, PRIMARY KEY(x, y)) }
@@ skipping 50 matching lines @@
 do_test e_fkey-19.2 {
   execsql {
     INSERT INTO parent VALUES(1, 2, 3, 4, 5, 6);
     INSERT INTO child1 VALUES('xxx', 1);
     INSERT INTO child2 VALUES('xxx', 2);
     INSERT INTO child3 VALUES(3, 4);
   }
 } {}
 do_test e_fkey-19.2 {
   catchsql { INSERT INTO child4 VALUES('xxx', 5) }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "child4" referencing "parent"}}
 do_test e_fkey-19.3 {
   catchsql { INSERT INTO child5 VALUES('xxx', 6) }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "child5" referencing "parent"}}
 do_test e_fkey-19.4 {
   catchsql { INSERT INTO child6 VALUES(2, 3) }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "child6" referencing "parent"}}
 do_test e_fkey-19.5 {
   catchsql { INSERT INTO child7 VALUES(3) }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "child7" referencing "parent"}}
 
 #-------------------------------------------------------------------------
 # Test errors in the database schema that are detected while preparing
 # DML statements. The error text for these messages always matches 
 # either "foreign key mismatch" or "no such table*" (using [string match]).
 #
 # EVIDENCE-OF: R-45488-08504 If the database schema contains foreign key
 # errors that require looking at more than one table definition to
 # identify, then those errors are not detected when the tables are
 # created.
@@ skipping 37 matching lines @@
     CREATE TABLE p6(a PRIMARY KEY, b);
     CREATE TABLE c6(c, d, FOREIGN KEY(c, d) REFERENCES p6);
 
     CREATE TABLE p7(a, b, PRIMARY KEY(a, b));
     CREATE TABLE c7(c, d REFERENCES p7);
   }
 } {}
 
 foreach {tn tbl ptbl err} {
   2 c1 {} "no such table: main.nosuchtable"
-  3 c2 p2 "foreign key mismatch"
-  4 c3 p3 "foreign key mismatch"
-  5 c4 p4 "foreign key mismatch"
-  6 c5 p5 "foreign key mismatch"
-  7 c6 p6 "foreign key mismatch"
-  8 c7 p7 "foreign key mismatch"
+  3 c2 p2 "foreign key mismatch - \"c2\" referencing \"p2\""
+  4 c3 p3 "foreign key mismatch - \"c3\" referencing \"p3\""
+  5 c4 p4 "foreign key mismatch - \"c4\" referencing \"p4\""
+  6 c5 p5 "foreign key mismatch - \"c5\" referencing \"p5\""
+  7 c6 p6 "foreign key mismatch - \"c6\" referencing \"p6\""
+  8 c7 p7 "foreign key mismatch - \"c7\" referencing \"p7\""
 } {
   do_test e_fkey-20.$tn.1 {
     catchsql "INSERT INTO $tbl VALUES('a', 'b')"
   } [list 1 $err]
   do_test e_fkey-20.$tn.2 {
     catchsql "UPDATE $tbl SET c = ?, d = ?"
   } [list 1 $err]
   do_test e_fkey-20.$tn.3 {
     catchsql "INSERT INTO $tbl SELECT ?, ?"
   } [list 1 $err]
@@ skipping 29 matching lines @@
   }
 } {}
 do_test e_fkey-21.2 {
   execsql {
     INSERT INTO parent2 VALUES('I', 'II');
     INSERT INTO child8 VALUES('I', 'II');
   }
 } {}
 do_test e_fkey-21.3 {
   catchsql { INSERT INTO child9 VALUES('I') }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "child9" referencing "parent2"}}
 do_test e_fkey-21.4 {
   catchsql { INSERT INTO child9 VALUES('II') }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "child9" referencing "parent2"}}
 do_test e_fkey-21.5 {
   catchsql { INSERT INTO child9 VALUES(NULL) }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "child9" referencing "parent2"}}
 do_test e_fkey-21.6 {
   catchsql { INSERT INTO child10 VALUES('I', 'II', 'III') }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "child10" referencing "parent2"}}
 do_test e_fkey-21.7 {
   catchsql { INSERT INTO child10 VALUES(1, 2, 3) }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "child10" referencing "parent2"}}
 do_test e_fkey-21.8 {
   catchsql { INSERT INTO child10 VALUES(NULL, NULL, NULL) }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "child10" referencing "parent2"}}
 
 #-------------------------------------------------------------------------
 # Test errors that are reported when creating the child table. 
 # Specifically:
 #
 #   * different number of child and parent key columns, and
 #   * child columns that do not exist.
 #
 # EVIDENCE-OF: R-23682-59820 By contrast, if foreign key errors can be
 # recognized simply by looking at the definition of the child table and
@@ skipping 39 matching lines @@
   execsql {
     CREATE TABLE p1(a, b, PRIMARY KEY(a, b));
     CREATE TABLE p2(a, b PRIMARY KEY);
     CREATE TABLE c1(c, d, FOREIGN KEY(c, d) REFERENCES p1);
     CREATE TABLE c2(a, b REFERENCES p2);
   }
 } {}
 proc test_efkey_60 {tn isError sql} {
   do_test e_fkey-23.$tn "
     catchsql {$sql}
-  " [lindex {{0 {}} {1 {foreign key constraint failed}}} $isError]
+  " [lindex {{0 {}} {1 {FOREIGN KEY constraint failed}}} $isError]
 }
 
 test_efkey_60 2 1 "INSERT INTO c1 VALUES(239, 231)"
 test_efkey_60 3 0 "INSERT INTO p1 VALUES(239, 231)"
 test_efkey_60 4 0 "INSERT INTO c1 VALUES(239, 231)"
 test_efkey_60 5 1 "INSERT INTO c2 VALUES(239, 231)"
 test_efkey_60 6 0 "INSERT INTO p2 VALUES(239, 231)"
 test_efkey_60 7 0 "INSERT INTO c2 VALUES(239, 231)"
 
 #-------------------------------------------------------------------------
@@ skipping 16 matching lines @@
     CREATE TABLE c1(a, b, FOREIGN KEY(a, b) REFERENCES parent(x, y));
     CREATE TABLE c2(a, b, FOREIGN KEY(a, b) REFERENCES parent(x, y));
     CREATE TABLE c3(a, b, FOREIGN KEY(a, b) REFERENCES parent(x, y));
     CREATE INDEX c2i ON c2(a, b);
     CREATE UNIQUE INDEX c3i ON c2(b, a);
   }
 } {}
 proc test_efkey_61 {tn isError sql} {
   do_test e_fkey-24.$tn "
     catchsql {$sql}
-  " [lindex {{0 {}} {1 {foreign key constraint failed}}} $isError]
+  " [lindex {{0 {}} {1 {FOREIGN KEY constraint failed}}} $isError]
 }
 foreach {tn c} [list 2 c1 3 c2 4 c3] {
   test_efkey_61 $tn.1 1 "INSERT INTO $c VALUES(1, 2)"
   test_efkey_61 $tn.2 0 "INSERT INTO parent VALUES(1, 2)"
   test_efkey_61 $tn.3 0 "INSERT INTO $c VALUES(1, 2)"
 
   execsql "DELETE FROM $c ; DELETE FROM parent"
 }
 
 #-------------------------------------------------------------------------
@@ skipping 20 matching lines @@
       trackartist INTEGER,
       FOREIGN KEY(trackartist) REFERENCES artist(artistid)
     );
   }
 } {}
 do_execsql_test e_fkey-25.2 {
   PRAGMA foreign_keys = OFF;
   EXPLAIN QUERY PLAN DELETE FROM artist WHERE 1;
   EXPLAIN QUERY PLAN SELECT rowid FROM track WHERE trackartist = ?;
 } {
-  0 0 0 {SCAN TABLE artist (~1000000 rows)} 
-  0 0 0 {SCAN TABLE track (~100000 rows)}
+  0 0 0 {SCAN TABLE artist} 
+  0 0 0 {SCAN TABLE track}
 }
 do_execsql_test e_fkey-25.3 {
   PRAGMA foreign_keys = ON;
   EXPLAIN QUERY PLAN DELETE FROM artist WHERE 1;
 } {
-  0 0 0 {SCAN TABLE artist (~1000000 rows)} 
-  0 0 0 {SCAN TABLE track (~100000 rows)}
+  0 0 0 {SCAN TABLE artist} 
+  0 0 0 {SCAN TABLE track}
 }
 do_test e_fkey-25.4 {
   execsql {
     INSERT INTO artist VALUES(5, 'artist 5');
     INSERT INTO artist VALUES(6, 'artist 6');
     INSERT INTO artist VALUES(7, 'artist 7');
     INSERT INTO track VALUES(1, 'track 1', 5);
     INSERT INTO track VALUES(2, 'track 2', 6);
   }
 } {}
 
 do_test e_fkey-25.5 {
   concat \
     [execsql { SELECT rowid FROM track WHERE trackartist = 5 }]   \
     [catchsql { DELETE FROM artist WHERE artistid = 5 }]
-} {1 1 {foreign key constraint failed}}
+} {1 1 {FOREIGN KEY constraint failed}}
 
 do_test e_fkey-25.6 {
   concat \
     [execsql { SELECT rowid FROM track WHERE trackartist = 7 }]   \
     [catchsql { DELETE FROM artist WHERE artistid = 7 }]
 } {0 {}}
 
 do_test e_fkey-25.7 {
   concat \
     [execsql { SELECT rowid FROM track WHERE trackartist = 6 }]   \
     [catchsql { DELETE FROM artist WHERE artistid = 6 }]
-} {2 1 {foreign key constraint failed}}
+} {2 1 {FOREIGN KEY constraint failed}}
 
 #-------------------------------------------------------------------------
 # EVIDENCE-OF: R-47936-10044 Or, more generally:
 # SELECT rowid FROM <child-table> WHERE <child-key> = :parent_key_value
 #
 # Test that when a row is deleted from the parent table of an FK 
 # constraint, the child table is queried for orphaned rows. The
 # query is equivalent to:
 #
 #   SELECT rowid FROM <child-table> WHERE <child-key> = :parent_key_value
@@ skipping 68 matching lines @@
     );
     CREATE INDEX trackindex ON track(trackartist);
   }
 } {}
 do_test e_fkey-27.2 {
   eqp { INSERT INTO artist VALUES(?, ?) }
 } {}
 do_execsql_test e_fkey-27.3 {
   EXPLAIN QUERY PLAN UPDATE artist SET artistid = ?, artistname = ?
 } {
-  0 0 0 {SCAN TABLE artist (~1000000 rows)} 
-  0 0 0 {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?) (~10 rows)} 
-  0 0 0 {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?) (~10 rows)}
+  0 0 0 {SCAN TABLE artist} 
+  0 0 0 {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?)} 
+  0 0 0 {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?)}
 }
 do_execsql_test e_fkey-27.4 {
   EXPLAIN QUERY PLAN DELETE FROM artist
 } {
-  0 0 0 {SCAN TABLE artist (~1000000 rows)} 
-  0 0 0 {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?) (~10 rows)}
+  0 0 0 {SCAN TABLE artist} 
+  0 0 0 {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?)}
 }
 
 
 ###########################################################################
 ### SECTION 4.1: Composite Foreign Key Constraints
 ###########################################################################
 
 #-------------------------------------------------------------------------
 # Check that parent and child keys must have the same number of columns.
 #
@@ skipping 24 matching lines @@
   drop_all_tables
   do_test e_fkey-28.$tn [list catchsql $sql] [list 1 $err]
 }
 do_test e_fkey-28.8 {
   drop_all_tables
   execsql {
     CREATE TABLE p(x PRIMARY KEY);
     CREATE TABLE c(a, b, FOREIGN KEY(a,b) REFERENCES p);
   }
   catchsql {DELETE FROM p}
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "c" referencing "p"}}
 do_test e_fkey-28.9 {
   drop_all_tables
   execsql {
     CREATE TABLE p(x, y, PRIMARY KEY(x,y));
     CREATE TABLE c(a REFERENCES p);
   }
   catchsql {DELETE FROM p}
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "c" referencing "p"}}
 
 
 #-------------------------------------------------------------------------
 # EVIDENCE-OF: R-24676-09859
 #
 # Test the example schema in the "Composite Foreign Key Constraints" 
 # section.
 #
 do_test e_fkey-29.1 {
   execsql {
@@ skipping 18 matching lines @@
     INSERT INTO album VALUES('Elvis Presley', 'Elvis'' Christmas Album', NULL);
     INSERT INTO song VALUES(
       1, 'Elvis Presley', 'Elvis'' Christmas Album', 'Here Comes Santa Clause'
     );
   }
 } {}
 do_test e_fkey-29.3 {
   catchsql {
     INSERT INTO song VALUES(2, 'Elvis Presley', 'Elvis Is Back!', 'Fever');
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 
 #-------------------------------------------------------------------------
 # EVIDENCE-OF: R-33626-48418 In SQLite, if any of the child key columns
 # (in this case songartist and songalbum) are NULL, then there is no
 # requirement for a corresponding row in the parent table.
 #
 do_test e_fkey-30.1 {
   execsql {
     INSERT INTO song VALUES(2, 'Elvis Presley', NULL, 'Fever');
@@ skipping 20 matching lines @@
 do_test e_fkey-31.1 {
   execsql {
     CREATE TABLE king(a, b, PRIMARY KEY(a));
     CREATE TABLE prince(c REFERENCES king, d);
   }
 } {}
 
 do_test e_fkey-31.2 {
   # Execute a statement that violates the immediate FK constraint.
   catchsql { INSERT INTO prince VALUES(1, 2) }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 do_test e_fkey-31.3 {
   # This time, use a trigger to fix the constraint violation before the
   # statement has finished executing. Then execute the same statement as
   # in the previous test case. This time, no error.
   execsql {
     CREATE TRIGGER kt AFTER INSERT ON prince WHEN
       NOT EXISTS (SELECT a FROM king WHERE a = new.c)
     BEGIN
       INSERT INTO king VALUES(new.c, NULL);
     END
   }
   execsql { INSERT INTO prince VALUES(1, 2) }
 } {}
 
 # Test that operating inside a transaction makes no difference to 
 # immediate constraint violation handling.
 do_test e_fkey-31.4 {
   execsql {
     BEGIN;
     INSERT INTO prince VALUES(2, 3);
     DROP TRIGGER kt;
   }
   catchsql { INSERT INTO prince VALUES(3, 4) }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-31.5 {
   execsql {
     COMMIT;
     SELECT * FROM king;
   }
 } {1 {} 2 {}}
 
 #-------------------------------------------------------------------------
 # Test that if a deferred constraint is violated within a transaction,
 # nothing happens immediately and the database is allowed to persist
@@ skipping 10 matching lines @@
 # EVIDENCE-OF: R-55147-47664 For as long as the user has an open
 # transaction, the database is allowed to exist in a state that violates
 # any number of deferred foreign key constraints.
 #
 # EVIDENCE-OF: R-29604-30395 However, COMMIT will fail as long as
 # foreign key constraints remain in violation.
 #
 proc test_efkey_34 {tn isError sql} {
   do_test e_fkey-32.$tn "
     catchsql {$sql}
-  " [lindex {{0 {}} {1 {foreign key constraint failed}}} $isError]
+  " [lindex {{0 {}} {1 {FOREIGN KEY constraint failed}}} $isError]
 }
 drop_all_tables
 
 test_efkey_34  1 0 {
   CREATE TABLE ll(k PRIMARY KEY);
   CREATE TABLE kk(c REFERENCES ll DEFERRABLE INITIALLY DEFERRED);
 }
 test_efkey_34  2 0 "BEGIN"
 test_efkey_34  3 0   "INSERT INTO kk VALUES(5)"
 test_efkey_34  4 0   "INSERT INTO kk VALUES(10)"
@@ skipping 10 matching lines @@
 # EVIDENCE-OF: R-56844-61705 If the current statement is not inside an
 # explicit transaction (a BEGIN/COMMIT/ROLLBACK block), then an implicit
 # transaction is committed as soon as the statement has finished
 # executing. In this case deferred constraints behave the same as
 # immediate constraints.
 #
 drop_all_tables
 proc test_efkey_35 {tn isError sql} {
   do_test e_fkey-33.$tn "
     catchsql {$sql}
-  " [lindex {{0 {}} {1 {foreign key constraint failed}}} $isError]
+  " [lindex {{0 {}} {1 {FOREIGN KEY constraint failed}}} $isError]
 }
 do_test e_fkey-33.1 {
   execsql {
     CREATE TABLE parent(x, y);
     CREATE UNIQUE INDEX pi ON parent(x, y);
     CREATE TABLE child(a, b,
       FOREIGN KEY(a, b) REFERENCES parent(x, y) DEFERRABLE INITIALLY DEFERRED
     );
   }
 } {}
@@ skipping 69 matching lines @@
     INSERT INTO c3 VALUES('g', 'h', 'i');
     INSERT INTO c4 VALUES('j', 'k', 'l');
     INSERT INTO c5 VALUES('m', 'n', 'o');
     INSERT INTO c6 VALUES('p', 'q', 'r');
     INSERT INTO c7 VALUES('s', 't', 'u');
   }
 } {}
 
 proc test_efkey_29 {tn sql isError} {
   do_test e_fkey-34.$tn "catchsql {$sql}" [
-    lindex {{0 {}} {1 {foreign key constraint failed}}} $isError
+    lindex {{0 {}} {1 {FOREIGN KEY constraint failed}}} $isError
   ]
 }
 test_efkey_29  2 "BEGIN"                                   0
 test_efkey_29  3 "DELETE FROM parent WHERE x = 'a'"        1
 test_efkey_29  4 "DELETE FROM parent WHERE x = 'd'"        1
 test_efkey_29  5 "DELETE FROM parent WHERE x = 'g'"        1
 test_efkey_29  6 "DELETE FROM parent WHERE x = 'j'"        1
 test_efkey_29  7 "DELETE FROM parent WHERE x = 'm'"        1
 test_efkey_29  8 "DELETE FROM parent WHERE x = 'p'"        1
 test_efkey_29  9 "DELETE FROM parent WHERE x = 's'"        0
@@ skipping 53 matching lines @@
       trackartist INTEGER REFERENCES artist(artistid) DEFERRABLE INITIALLY DEFERRED
     );
   }
 } {}
 do_test e_fkey-35.2 {
   execsql {
     BEGIN;
       INSERT INTO track VALUES(1, 'White Christmas', 5);
   }
   catchsql COMMIT
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-35.3 {
   execsql {
     INSERT INTO artist VALUES(5, 'Bing Crosby');
     COMMIT;
   }
 } {}
 
 #-------------------------------------------------------------------------
 # Verify that a nested savepoint may be released without satisfying 
 # deferred foreign key constraints.
@@ skipping 16 matching lines @@
 do_test e_fkey-36.2 {
   execsql {
     BEGIN;
       SAVEPOINT one;
         INSERT INTO t1 VALUES(4, 5);
       RELEASE one;
   }
 } {}
 do_test e_fkey-36.3 {
   catchsql COMMIT
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-36.4 {
   execsql {
     UPDATE t1 SET a = 5 WHERE a = 4;
     COMMIT;
   }
 } {}
 
 
 #-------------------------------------------------------------------------
 # Check that a transaction savepoint (an outermost savepoint opened when
 # the database was in auto-commit mode) cannot be released without
 # satisfying deferred foreign key constraints. It may be rolled back.
 #
 # EVIDENCE-OF: R-44295-13823 A transaction savepoint (a non-nested
 # savepoint that was opened while there was not currently an open
 # transaction), on the other hand, is subject to the same restrictions
 # as a COMMIT - attempting to RELEASE it while the database is in such a
 # state will fail.
 #
 do_test e_fkey-37.1 {
   execsql {
     SAVEPOINT one;
       SAVEPOINT two;
         INSERT INTO t1 VALUES(6, 7);
       RELEASE two;
   }
 } {}
 do_test e_fkey-37.2 {
   catchsql {RELEASE one}
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-37.3 {
   execsql {
       UPDATE t1 SET a = 7 WHERE a = 6;
     RELEASE one;
   }
 } {}
 do_test e_fkey-37.4 {
   execsql {
     SAVEPOINT one;
       SAVEPOINT two;
         INSERT INTO t1 VALUES(9, 10);
       RELEASE two;
   }
 } {}
 do_test e_fkey-37.5 {
   catchsql {RELEASE one}
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-37.6 {
   execsql {ROLLBACK TO one ; RELEASE one}
 } {}
 
 #-------------------------------------------------------------------------
 # Test that if a COMMIT operation fails due to deferred foreign key 
 # constraints, any nested savepoints remain open.
 #
 # EVIDENCE-OF: R-37736-42616 If a COMMIT statement (or the RELEASE of a
 # transaction SAVEPOINT) fails because the database is currently in a
@@ skipping 10 matching lines @@
   execsql {
     BEGIN;
       INSERT INTO t1 VALUES(4, 4);
       SAVEPOINT one;
         INSERT INTO t1 VALUES(5, 6);
         SELECT * FROM t1;
   }
 } {1 1 2 2 3 3 4 4 5 6}
 do_test e_fkey-38.3 {
   catchsql COMMIT
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-38.4 {
   execsql {
     ROLLBACK TO one;
     COMMIT;
     SELECT * FROM t1;
   }
 } {1 1 2 2 3 3 4 4}
 
 do_test e_fkey-38.5 {
   execsql {
     SAVEPOINT a;
       INSERT INTO t1 VALUES(5, 5);
       SAVEPOINT b;
         INSERT INTO t1 VALUES(6, 7);
         SAVEPOINT c;
           INSERT INTO t1 VALUES(7, 8);
   }
 } {}
 do_test e_fkey-38.6 {
   catchsql {RELEASE a}
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-38.7 {
   execsql  {ROLLBACK TO c}
   catchsql {RELEASE a}
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-38.8 {
   execsql  {
     ROLLBACK TO b;
     RELEASE a;
     SELECT * FROM t1;
   }
 } {1 1 2 2 3 3 4 4 5 5}
 
 ###########################################################################
 ### SECTION 4.3: ON DELETE and ON UPDATE Actions
@@ skipping 130 matching lines @@
 do_test e_fkey-41.2 {
   execsql {
     BEGIN;
       UPDATE parent SET p1='k' WHERE p1='j';
       DELETE FROM parent WHERE p1='l';
       SELECT * FROM child;
   }
 } {j k l m}
 do_test e_fkey-41.3 {
   catchsql COMMIT
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-41.4 {
   execsql ROLLBACK
 } {}
 
 #-------------------------------------------------------------------------
 # Test that "RESTRICT" means the application is prohibited from deleting
 # or updating a parent table row when there exists one or more child keys
 # mapped to it.
 #
 # EVIDENCE-OF: R-04272-38653 The "RESTRICT" action means that the
@@ skipping 17 matching lines @@
 do_test e_fkey-41.2 {
   execsql {
     INSERT INTO parent VALUES('a', 'b');
     INSERT INTO parent VALUES('c', 'd');
     INSERT INTO child1 VALUES('b', 'a');
     INSERT INTO child2 VALUES('d', 'c');
   }
 } {}
 do_test e_fkey-41.3 {
   catchsql { DELETE FROM parent WHERE p1 = 'a' }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-41.4 {
   catchsql { UPDATE parent SET p2 = 'e' WHERE p1 = 'c' }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 #-------------------------------------------------------------------------
 # Test that RESTRICT is slightly different from NO ACTION for IMMEDIATE
 # constraints, in that it is enforced immediately, not at the end of the 
 # statement.
 #
 # EVIDENCE-OF: R-37997-42187 The difference between the effect of a
 # RESTRICT action and normal foreign key constraint enforcement is that
 # the RESTRICT action processing happens as soon as the field is updated
 # - not at the end of the current statement as it would with an
@@ skipping 13 matching lines @@
     INSERT INTO child2 VALUES('key2');
 
     CREATE TRIGGER parent_t AFTER UPDATE ON parent BEGIN
       UPDATE child1 set c = new.x WHERE c = old.x;
       UPDATE child2 set c = new.x WHERE c = old.x;
     END;
   }
 } {}
 do_test e_fkey-42.2 {
   catchsql { UPDATE parent SET x = 'key one' WHERE x = 'key1' }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-42.3 {
   execsql { 
     UPDATE parent SET x = 'key two' WHERE x = 'key2';
     SELECT * FROM child2;
   }
 } {{key two}}
 
 drop_all_tables
 do_test e_fkey-42.4 {
   execsql {
     CREATE TABLE parent(x PRIMARY KEY);
     CREATE TABLE child1(c REFERENCES parent ON DELETE RESTRICT);
     CREATE TABLE child2(c REFERENCES parent ON DELETE NO ACTION);
 
     INSERT INTO parent VALUES('key1');
     INSERT INTO parent VALUES('key2');
     INSERT INTO child1 VALUES('key1');
     INSERT INTO child2 VALUES('key2');
 
     CREATE TRIGGER parent_t AFTER DELETE ON parent BEGIN
       UPDATE child1 SET c = NULL WHERE c = old.x;
       UPDATE child2 SET c = NULL WHERE c = old.x;
     END;
   }
 } {}
 do_test e_fkey-42.5 {
   catchsql { DELETE FROM parent WHERE x = 'key1' }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-42.6 {
   execsql { 
     DELETE FROM parent WHERE x = 'key2';
     SELECT * FROM child2;
   }
 } {{}}
 
 drop_all_tables
 do_test e_fkey-42.7 {
   execsql {
     CREATE TABLE parent(x PRIMARY KEY);
     CREATE TABLE child1(c REFERENCES parent ON DELETE RESTRICT);
     CREATE TABLE child2(c REFERENCES parent ON DELETE NO ACTION);
 
     INSERT INTO parent VALUES('key1');
     INSERT INTO parent VALUES('key2');
     INSERT INTO child1 VALUES('key1');
     INSERT INTO child2 VALUES('key2');
   }
 } {}
 do_test e_fkey-42.8 {
   catchsql { REPLACE INTO parent VALUES('key1') }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-42.9 {
   execsql { 
     REPLACE INTO parent VALUES('key2');
     SELECT * FROM child2;
   }
 } {key2}
 
 #-------------------------------------------------------------------------
 # Test that RESTRICT is enforced immediately, even for a DEFERRED constraint.
 #
@@ skipping 15 matching lines @@
 
     INSERT INTO parent VALUES('key1');
     INSERT INTO parent VALUES('key2');
     INSERT INTO child1 VALUES('key1');
     INSERT INTO child2 VALUES('key2');
     BEGIN;
   }
 } {}
 do_test e_fkey-43.2 {
   catchsql { UPDATE parent SET x = 'key one' WHERE x = 'key1' }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-43.3 {
   execsql { UPDATE parent SET x = 'key two' WHERE x = 'key2' }
 } {}
 do_test e_fkey-43.4 {
   catchsql COMMIT
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-43.5 {
   execsql {
     UPDATE child2 SET c = 'key two';
     COMMIT;
   }
 } {}
 
 drop_all_tables
 do_test e_fkey-43.6 {
   execsql {
     CREATE TABLE parent(x PRIMARY KEY);
     CREATE TABLE child1(c REFERENCES parent ON DELETE RESTRICT
       DEFERRABLE INITIALLY DEFERRED
     );
     CREATE TABLE child2(c REFERENCES parent ON DELETE NO ACTION
       DEFERRABLE INITIALLY DEFERRED
     );
 
     INSERT INTO parent VALUES('key1');
     INSERT INTO parent VALUES('key2');
     INSERT INTO child1 VALUES('key1');
     INSERT INTO child2 VALUES('key2');
     BEGIN;
   }
 } {}
 do_test e_fkey-43.7 {
   catchsql { DELETE FROM parent WHERE x = 'key1' }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-43.8 {
   execsql { DELETE FROM parent WHERE x = 'key2' }
 } {}
 do_test e_fkey-43.9 {
   catchsql COMMIT
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-43.10 {
   execsql {
     UPDATE child2 SET c = NULL;
     COMMIT;
   }
 } {}
 
 #-------------------------------------------------------------------------
 # Test SET NULL actions.
 #
@@ skipping 56 matching lines @@
     INSERT INTO pA(rowid, x) VALUES(3, X'ABCD');
     INSERT INTO pA(rowid, x) VALUES(4, X'1234');
 
     INSERT INTO cA VALUES(X'ABCD');
     INSERT INTO cB VALUES(X'1234');
   }
 } {}
 do_test e_fkey-45.2 {
   execsql {
     DELETE FROM pA WHERE rowid = 3;
-    SELECT quote(x) FROM pA;
+    SELECT quote(x) FROM pA ORDER BY rowid;
   }
 } {X'0000' X'9999' X'1234'}
 do_test e_fkey-45.3 {
   execsql { SELECT quote(c) FROM cA }
 } {X'0000'}
 do_test e_fkey-45.4 {
   execsql {
     UPDATE pA SET x = X'8765' WHERE rowid = 4;
-    SELECT quote(x) FROM pA;
+    SELECT quote(x) FROM pA ORDER BY rowid;
   }
 } {X'0000' X'9999' X'8765'}
 do_test e_fkey-45.5 {
   execsql { SELECT quote(c) FROM cB }
 } {X'9999'}
 
 #-------------------------------------------------------------------------
 # Test ON DELETE CASCADE actions.
 #
 # EVIDENCE-OF: R-61376-57267 A "CASCADE" action propagates the delete or
@@ skipping 149 matching lines @@
 } {a two c}
 do_test e_fkey-49.3 {
   execsql {
     ROLLBACK;
     DELETE FROM parent WHERE a = 'A';
     SELECT * FROM parent;
   }
 } {ONE two three}
 do_test e_fkey-49.4 {
   catchsql { UPDATE parent SET a = '' WHERE a = 'oNe' }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 
 
 #-------------------------------------------------------------------------
 # EVIDENCE-OF: R-11856-19836
 #
 # Test an example from the "ON DELETE and ON UPDATE Actions" section 
 # of foreignkeys.html. This example shows that adding an "ON DELETE DEFAULT"
 # clause does not abrogate the need to satisfy the foreign key constraint
 # (R-28220-46694).
 #
@@ skipping 14 matching lines @@
       trackid     INTEGER,
       trackname   TEXT, 
       trackartist INTEGER DEFAULT 0 REFERENCES artist(artistid) ON DELETE SET DEFAULT
     );
     INSERT INTO artist VALUES(3, 'Sammy Davis Jr.');
     INSERT INTO track VALUES(14, 'Mr. Bojangles', 3);
   }
 } {}
 do_test e_fkey-50.2 {
   catchsql { DELETE FROM artist WHERE artistname = 'Sammy Davis Jr.' }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-50.3 {
   execsql {
     INSERT INTO artist VALUES(0, 'Unknown Artist');
     DELETE FROM artist WHERE artistname = 'Sammy Davis Jr.';
   }
 } {}
 do_test e_fkey-50.4 {
   execsql { SELECT * FROM artist }
 } {0 {Unknown Artist}}
 do_test e_fkey-50.5 {
@@ skipping 30 matching lines @@
       INSERT INTO parent VALUES(new.x+old.x);
     END;
 
     INSERT INTO parent VALUES(1);
     INSERT INTO child VALUES(1);
   }
 } {}
 do_test e_fkey-51.2 {
   execsql {
     UPDATE parent SET x = 22;
-    SELECT * FROM parent UNION ALL SELECT 'xxx' UNION ALL SELECT a FROM child;
+    SELECT * FROM parent ORDER BY rowid; SELECT 'xxx' ; SELECT a FROM child;
   }
 } {22 21 23 xxx 22}
 do_test e_fkey-51.3 {
   execsql {
     DELETE FROM child;
     DELETE FROM parent;
     INSERT INTO parent VALUES(-1);
     INSERT INTO child VALUES(-1);
     UPDATE parent SET x = 22;
-    SELECT * FROM parent UNION ALL SELECT 'xxx' UNION ALL SELECT a FROM child;
+    SELECT * FROM parent ORDER BY rowid; SELECT 'xxx' ; SELECT a FROM child;
   }
 } {22 23 21 xxx 23}
 
 
 #-------------------------------------------------------------------------
 # Verify that ON UPDATE actions only actually take place if the parent key
 # is set to a new value that is distinct from the old value. The default
 # collation sequence and affinity are used to determine if the new value
 # is 'distinct' from the old or not.
 #
@@ skipping 282 matching lines @@
 # violated, the DROP TABLE statement fails and the table is not dropped.
 #
 do_test e_fkey-58.1 {
   execsql { 
     DELETE FROM c1;
     DELETE FROM c2;
     DELETE FROM c3;
   }
   execsql { INSERT INTO c5 VALUES('a', 'b') }
   catchsql { DROP TABLE p }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-58.2 {
   execsql { SELECT * FROM p }
 } {a b}
 do_test e_fkey-58.3 {
   catchsql {
     BEGIN;
       DROP TABLE p;
   }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-58.4 {
   execsql {
     SELECT * FROM p;
     SELECT * FROM c5;
     ROLLBACK;
   }
 } {a b a b}
 
 #-------------------------------------------------------------------------
 # If a DEFERRED foreign key fails as a result of a DROP TABLE, attempting
@@ skipping 13 matching lines @@
 } {}
 do_test e_fkey-59.2 {
   execsql { INSERT INTO c7 VALUES('a', 'b') }
   execsql {
     BEGIN;
       DROP TABLE p;
   }
 } {}
 do_test e_fkey-59.3 {
   catchsql COMMIT
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-59.4 {
   execsql { CREATE TABLE p(a, b, PRIMARY KEY(a, b)) }
   catchsql COMMIT
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-59.5 {
   execsql { INSERT INTO p VALUES('a', 'b') }
   execsql COMMIT
 } {}
 
 #-------------------------------------------------------------------------
 # Any "foreign key mismatch" errors encountered while running an implicit
 # "DELETE FROM tbl" are ignored.
 #
 # EVIDENCE-OF: R-57242-37005 Any "foreign key mismatch" errors
@@ skipping 23 matching lines @@
   execsql {
     BEGIN;
       DROP TABLE p;
       SELECT * FROM c3;
     ROLLBACK;
   }
 } {{} 2}
 do_test e_fkey-60.4 {
   execsql { CREATE TABLE nosuchtable(x PRIMARY KEY) }
   catchsql { DELETE FROM p }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "c2" referencing "p"}}
 do_test e_fkey-60.5 {
   execsql { DROP TABLE c1 }
   catchsql { DELETE FROM p }
-} {1 {foreign key mismatch}}
+} {1 {foreign key mismatch - "c2" referencing "p"}}
 do_test e_fkey-60.6 {
   execsql { DROP TABLE c2 }
   execsql { DELETE FROM p }
 } {}
 
 #-------------------------------------------------------------------------
-# Test that the special behaviours of ALTER and DROP TABLE are only
-# activated when foreign keys are enabled. Special behaviours are:
+# Test that the special behaviors of ALTER and DROP TABLE are only
+# activated when foreign keys are enabled. Special behaviors are:
 #
 #   1. ADD COLUMN not allowing a REFERENCES clause with a non-NULL 
 #      default value.
 #   2. Modifying foreign key definitions when a parent table is RENAMEd.
 #   3. Running an implicit DELETE FROM command as part of DROP TABLE.
 #
 # EVIDENCE-OF: R-54142-41346 The properties of the DROP TABLE and ALTER
 # TABLE commands described above only apply if foreign keys are enabled.
 #
 do_test e_fkey-61.1.1 {
@@ skipping 74 matching lines @@
   drop_all_tables
   do_test e_fkey-62.$zMatch.1 {
     execsql "
       CREATE TABLE p(a, b, c, PRIMARY KEY(b, c));
       CREATE TABLE c(d, e, f, FOREIGN KEY(e, f) REFERENCES p MATCH $zMatch);
     "
   } {}
   do_test e_fkey-62.$zMatch.2 {
     execsql { INSERT INTO p VALUES(1, 2, 3)         }
 
-    # MATCH SIMPLE behaviour: Allow any child key that contains one or more
+    # MATCH SIMPLE behavior: Allow any child key that contains one or more
     # NULL value to be inserted. Non-NULL values do not have to map to any
     # parent key values, so long as at least one field of the child key is
     # NULL.
     execsql { INSERT INTO c VALUES('w', 2, 3)       }
     execsql { INSERT INTO c VALUES('x', 'x', NULL)  }
     execsql { INSERT INTO c VALUES('y', NULL, 'x')  }
     execsql { INSERT INTO c VALUES('z', NULL, NULL) }
 
     # Check that the FK is enforced properly if there are no NULL values 
     # in the child key columns.
     catchsql { INSERT INTO c VALUES('a', 2, 4) }
-  } {1 {foreign key constraint failed}}
+  } {1 {FOREIGN KEY constraint failed}}
 }
 
 #-------------------------------------------------------------------------
 # Test that SQLite does not support the SET CONSTRAINT statement. And
 # that it is possible to create both immediate and deferred constraints.
 #
 # EVIDENCE-OF: R-21599-16038 In SQLite, a foreign key constraint is
 # permanently marked as deferred or immediate when it is created.
 #
 drop_all_tables
 do_test e_fkey-62.1 {
   catchsql { SET CONSTRAINTS ALL IMMEDIATE }
 } {1 {near "SET": syntax error}}
 do_test e_fkey-62.2 {
   catchsql { SET CONSTRAINTS ALL DEFERRED }
 } {1 {near "SET": syntax error}}
 
 do_test e_fkey-62.3 {
   execsql {
     CREATE TABLE p(a, b, PRIMARY KEY(a, b));
     CREATE TABLE cd(c, d, 
       FOREIGN KEY(c, d) REFERENCES p DEFERRABLE INITIALLY DEFERRED);
     CREATE TABLE ci(c, d, 
       FOREIGN KEY(c, d) REFERENCES p DEFERRABLE INITIALLY IMMEDIATE);
     BEGIN;
   }
 } {}
 do_test e_fkey-62.4 {
   catchsql { INSERT INTO ci VALUES('x', 'y') }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-62.5 {
   catchsql { INSERT INTO cd VALUES('x', 'y') }
 } {0 {}}
 do_test e_fkey-62.6 {
   catchsql { COMMIT }
-} {1 {foreign key constraint failed}}
+} {1 {FOREIGN KEY constraint failed}}
 do_test e_fkey-62.7 {
   execsql { 
     DELETE FROM cd;
     COMMIT;
   }
 } {}
 
 #-------------------------------------------------------------------------
 # Test that the maximum recursion depth of foreign key action programs is
 # governed by the SQLITE_MAX_TRIGGER_DEPTH and SQLITE_LIMIT_TRIGGER_DEPTH
@@ skipping 40 matching lines @@
       INSERT INTO t$i VALUES('xxx');
     "
   }
   execsql COMMIT
   catchsql "
     UPDATE t0 SET a = 'yyy';
     SELECT NOT (a='yyy') FROM t$limit;
   "
 }
 
-do_test e_fkey-63.1.1 {
-  test_on_delete_recursion $SQLITE_MAX_TRIGGER_DEPTH
-} {0 0}
-do_test e_fkey-63.1.2 {
-  test_on_delete_recursion [expr $SQLITE_MAX_TRIGGER_DEPTH+1]
-} {1 {too many levels of trigger recursion}}
-do_test e_fkey-63.1.3 {
-  sqlite3_limit db SQLITE_LIMIT_TRIGGER_DEPTH 5
-  test_on_delete_recursion 5
-} {0 0}
-do_test e_fkey-63.1.4 {
-  test_on_delete_recursion 6
-} {1 {too many levels of trigger recursion}}
-do_test e_fkey-63.1.5 {
-  sqlite3_limit db SQLITE_LIMIT_TRIGGER_DEPTH 1000000
-} {5}
-do_test e_fkey-63.2.1 {
-  test_on_update_recursion $SQLITE_MAX_TRIGGER_DEPTH
-} {0 0}
-do_test e_fkey-63.2.2 {
-  test_on_update_recursion [expr $SQLITE_MAX_TRIGGER_DEPTH+1]
-} {1 {too many levels of trigger recursion}}
-do_test e_fkey-63.2.3 {
-  sqlite3_limit db SQLITE_LIMIT_TRIGGER_DEPTH 5
-  test_on_update_recursion 5
-} {0 0}
-do_test e_fkey-63.2.4 {
-  test_on_update_recursion 6
-} {1 {too many levels of trigger recursion}}
-do_test e_fkey-63.2.5 {
-  sqlite3_limit db SQLITE_LIMIT_TRIGGER_DEPTH 1000000
-} {5}
+# If the current build was created using clang with the -fsanitize=address
+# switch, then the library uses considerably more stack space than usual.
+# So much more, that some of the following tests cause stack overflows
+# if they are run under this configuration.
+#
+if {[clang_sanitize_address]==0} {
+  do_test e_fkey-63.1.1 {
+    test_on_delete_recursion $SQLITE_MAX_TRIGGER_DEPTH
+  } {0 0}
+  do_test e_fkey-63.1.2 {
+    test_on_delete_recursion [expr $SQLITE_MAX_TRIGGER_DEPTH+1]
+  } {1 {too many levels of trigger recursion}}
+  do_test e_fkey-63.1.3 {
+    sqlite3_limit db SQLITE_LIMIT_TRIGGER_DEPTH 5
+      test_on_delete_recursion 5
+  } {0 0}
+  do_test e_fkey-63.1.4 {
+    test_on_delete_recursion 6
+  } {1 {too many levels of trigger recursion}}
+  do_test e_fkey-63.1.5 {
+    sqlite3_limit db SQLITE_LIMIT_TRIGGER_DEPTH 1000000
+  } {5}
+  do_test e_fkey-63.2.1 {
+    test_on_update_recursion $SQLITE_MAX_TRIGGER_DEPTH
+  } {0 0}
+  do_test e_fkey-63.2.2 {
+    test_on_update_recursion [expr $SQLITE_MAX_TRIGGER_DEPTH+1]
+  } {1 {too many levels of trigger recursion}}
+  do_test e_fkey-63.2.3 {
+    sqlite3_limit db SQLITE_LIMIT_TRIGGER_DEPTH 5
+      test_on_update_recursion 5
+  } {0 0}
+  do_test e_fkey-63.2.4 {
+    test_on_update_recursion 6
+  } {1 {too many levels of trigger recursion}}
+  do_test e_fkey-63.2.5 {
+    sqlite3_limit db SQLITE_LIMIT_TRIGGER_DEPTH 1000000
+  } {5}
+}
 
 #-------------------------------------------------------------------------
 # The setting of the recursive_triggers pragma does not affect foreign
 # key actions.
 #
-# EVIDENCE-OF: R-51769-32730 The PRAGMA recursive_triggers setting does
-# not not affect the operation of foreign key actions.
+# EVIDENCE-OF: R-44355-00270 The PRAGMA recursive_triggers setting does
+# not affect the operation of foreign key actions.
 #
 foreach recursive_triggers_setting [list 0 1 ON OFF] {
   drop_all_tables
   execsql "PRAGMA recursive_triggers = $recursive_triggers_setting"
 
   do_test e_fkey-64.$recursive_triggers_setting.1 {
     execsql {
       CREATE TABLE t1(a PRIMARY KEY, b REFERENCES t1 ON DELETE CASCADE);
       INSERT INTO t1 VALUES(1, NULL);
       INSERT INTO t1 VALUES(2, 1);
       INSERT INTO t1 VALUES(3, 2);
       INSERT INTO t1 VALUES(4, 3);
       INSERT INTO t1 VALUES(5, 4);
       SELECT count(*) FROM t1;
     }
   } {5}
   do_test e_fkey-64.$recursive_triggers_setting.2 {
     execsql { SELECT count(*) FROM t1 WHERE a = 1 }
   } {1}
   do_test e_fkey-64.$recursive_triggers_setting.3 {
     execsql { 
       DELETE FROM t1 WHERE a = 1;
       SELECT count(*) FROM t1;
     }
   } {0}
 }
 
 finish_test