sl@0: #
sl@0: # 2001 September 15
sl@0: #
sl@0: # The author disclaims copyright to this source code.  In place of
sl@0: # a legal notice, here is a blessing:
sl@0: #
sl@0: #    May you do good and not evil.
sl@0: #    May you find forgiveness for yourself and forgive others.
sl@0: #    May you share freely, never taking more than you give.
sl@0: #
sl@0: #***********************************************************************
sl@0: # This file implements regression tests for SQLite library.  The
sl@0: # focus of this script is page cache subsystem.
sl@0: #
sl@0: # $Id: collate4.test,v 1.9 2008/01/05 17:39:30 danielk1977 Exp $
sl@0: 
sl@0: set testdir [file dirname $argv0]
sl@0: source $testdir/tester.tcl
sl@0: 
sl@0: db collate TEXT text_collate
sl@0: proc text_collate {a b} {
sl@0:   return [string compare $a $b]
sl@0: }
sl@0: 
sl@0: # Do an SQL statement.  Append the search count to the end of the result.
sl@0: #
sl@0: proc count sql {
sl@0:   set ::sqlite_search_count 0
sl@0:   return [concat [execsql $sql] $::sqlite_search_count]
sl@0: }
sl@0: 
sl@0: # This procedure executes the SQL.  Then it checks the generated program
sl@0: # for the SQL and appends a "nosort" to the result if the program contains the
sl@0: # SortCallback opcode.  If the program does not contain the SortCallback
sl@0: # opcode it appends "sort"
sl@0: #
sl@0: proc cksort {sql} {
sl@0:   set ::sqlite_sort_count 0
sl@0:   set data [execsql $sql]
sl@0:   if {$::sqlite_sort_count} {set x sort} {set x nosort}
sl@0:   lappend data $x
sl@0:   return $data
sl@0: }
sl@0: 
sl@0: # 
sl@0: # Test cases are organized roughly as follows:
sl@0: #
sl@0: # collate4-1.*      ORDER BY.
sl@0: # collate4-2.*      WHERE clauses.
sl@0: # collate4-3.*      constraints (primary key, unique).
sl@0: # collate4-4.*      simple min() or max() queries.
sl@0: # collate4-5.*      REINDEX command
sl@0: # collate4-6.*      INTEGER PRIMARY KEY indices.
sl@0: #
sl@0: 
sl@0: #
sl@0: # These tests - collate4-1.* - check that indices are correctly
sl@0: # selected or not selected to implement ORDER BY clauses when 
sl@0: # user defined collation sequences are involved. 
sl@0: #
sl@0: # Because these tests also exercise all the different ways indices 
sl@0: # can be created, they also serve to verify that indices are correctly 
sl@0: # initialised with user-defined collation sequences when they are
sl@0: # created.
sl@0: #
sl@0: # Tests named collate4-1.1.* use indices with a single column. Tests
sl@0: # collate4-1.2.* use indices with two columns.
sl@0: #
sl@0: do_test collate4-1.1.0 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t1(a COLLATE NOCASE, b COLLATE TEXT);
sl@0:     INSERT INTO collate4t1 VALUES( 'a', 'a' );
sl@0:     INSERT INTO collate4t1 VALUES( 'b', 'b' );
sl@0:     INSERT INTO collate4t1 VALUES( NULL, NULL );
sl@0:     INSERT INTO collate4t1 VALUES( 'B', 'B' );
sl@0:     INSERT INTO collate4t1 VALUES( 'A', 'A' );
sl@0:     CREATE INDEX collate4i1 ON collate4t1(a);
sl@0:     CREATE INDEX collate4i2 ON collate4t1(b);
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-1.1.1 {
sl@0:   cksort {SELECT a FROM collate4t1 ORDER BY a}
sl@0: } {{} a A b B nosort}
sl@0: do_test collate4-1.1.2 {
sl@0:   cksort {SELECT a FROM collate4t1 ORDER BY a COLLATE NOCASE}
sl@0: } {{} a A b B nosort}
sl@0: do_test collate4-1.1.3 {
sl@0:   cksort {SELECT a FROM collate4t1 ORDER BY a COLLATE TEXT}
sl@0: } {{} A B a b sort}
sl@0: do_test collate4-1.1.4 {
sl@0:   cksort {SELECT b FROM collate4t1 ORDER BY b}
sl@0: } {{} A B a b nosort}
sl@0: do_test collate4-1.1.5 {
sl@0:   cksort {SELECT b FROM collate4t1 ORDER BY b COLLATE TEXT}
sl@0: } {{} A B a b nosort}
sl@0: do_test collate4-1.1.6 {
sl@0:   cksort {SELECT b FROM collate4t1 ORDER BY b COLLATE NOCASE}
sl@0: } {{} a A b B sort}
sl@0: 
sl@0: do_test collate4-1.1.7 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t2(
sl@0:       a PRIMARY KEY COLLATE NOCASE, 
sl@0:       b UNIQUE COLLATE TEXT
sl@0:     );
sl@0:     INSERT INTO collate4t2 VALUES( 'a', 'a' );
sl@0:     INSERT INTO collate4t2 VALUES( NULL, NULL );
sl@0:     INSERT INTO collate4t2 VALUES( 'B', 'B' );
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-1.1.8 {
sl@0:   cksort {SELECT a FROM collate4t2 ORDER BY a}
sl@0: } {{} a B nosort}
sl@0: do_test collate4-1.1.9 {
sl@0:   cksort {SELECT a FROM collate4t2 ORDER BY a COLLATE NOCASE}
sl@0: } {{} a B nosort}
sl@0: do_test collate4-1.1.10 {
sl@0:   cksort {SELECT a FROM collate4t2 ORDER BY a COLLATE TEXT}
sl@0: } {{} B a sort}
sl@0: do_test collate4-1.1.11 {
sl@0:   cksort {SELECT b FROM collate4t2 ORDER BY b}
sl@0: } {{} B a nosort}
sl@0: do_test collate4-1.1.12 {
sl@0:   cksort {SELECT b FROM collate4t2 ORDER BY b COLLATE TEXT}
sl@0: } {{} B a nosort}
sl@0: do_test collate4-1.1.13 {
sl@0:   cksort {SELECT b FROM collate4t2 ORDER BY b COLLATE NOCASE}
sl@0: } {{} a B sort}
sl@0: 
sl@0: do_test collate4-1.1.14 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t3(
sl@0:       b COLLATE TEXT,  
sl@0:       a COLLATE NOCASE, 
sl@0:       UNIQUE(a), PRIMARY KEY(b)
sl@0:     );
sl@0:     INSERT INTO collate4t3 VALUES( 'a', 'a' );
sl@0:     INSERT INTO collate4t3 VALUES( NULL, NULL );
sl@0:     INSERT INTO collate4t3 VALUES( 'B', 'B' );
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-1.1.15 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a}
sl@0: } {{} a B nosort}
sl@0: do_test collate4-1.1.16 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a COLLATE NOCASE}
sl@0: } {{} a B nosort}
sl@0: do_test collate4-1.1.17 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a COLLATE TEXT}
sl@0: } {{} B a sort}
sl@0: do_test collate4-1.1.18 {
sl@0:   cksort {SELECT b FROM collate4t3 ORDER BY b}
sl@0: } {{} B a nosort}
sl@0: do_test collate4-1.1.19 {
sl@0:   cksort {SELECT b FROM collate4t3 ORDER BY b COLLATE TEXT}
sl@0: } {{} B a nosort}
sl@0: do_test collate4-1.1.20 {
sl@0:   cksort {SELECT b FROM collate4t3 ORDER BY b COLLATE NOCASE}
sl@0: } {{} a B sort}
sl@0: 
sl@0: do_test collate4-1.1.21 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t4(a COLLATE NOCASE, b COLLATE TEXT);
sl@0:     INSERT INTO collate4t4 VALUES( 'a', 'a' );
sl@0:     INSERT INTO collate4t4 VALUES( 'b', 'b' );
sl@0:     INSERT INTO collate4t4 VALUES( NULL, NULL );
sl@0:     INSERT INTO collate4t4 VALUES( 'B', 'B' );
sl@0:     INSERT INTO collate4t4 VALUES( 'A', 'A' );
sl@0:     CREATE INDEX collate4i3 ON collate4t4(a COLLATE TEXT);
sl@0:     CREATE INDEX collate4i4 ON collate4t4(b COLLATE NOCASE);
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-1.1.22 {
sl@0:   cksort {SELECT a FROM collate4t4 ORDER BY a}
sl@0: } {{} a A b B sort}
sl@0: do_test collate4-1.1.23 {
sl@0:   cksort {SELECT a FROM collate4t4 ORDER BY a COLLATE NOCASE}
sl@0: } {{} a A b B sort}
sl@0: do_test collate4-1.1.24 {
sl@0:   cksort {SELECT a FROM collate4t4 ORDER BY a COLLATE TEXT}
sl@0: } {{} A B a b nosort}
sl@0: do_test collate4-1.1.25 {
sl@0:   cksort {SELECT b FROM collate4t4 ORDER BY b}
sl@0: } {{} A B a b sort}
sl@0: do_test collate4-1.1.26 {
sl@0:   cksort {SELECT b FROM collate4t4 ORDER BY b COLLATE TEXT}
sl@0: } {{} A B a b sort}
sl@0: do_test collate4-1.1.27 {
sl@0:   cksort {SELECT b FROM collate4t4 ORDER BY b COLLATE NOCASE}
sl@0: } {{} a A b B nosort}
sl@0: 
sl@0: do_test collate4-1.1.30 {
sl@0:   execsql {
sl@0:     DROP TABLE collate4t1;
sl@0:     DROP TABLE collate4t2;
sl@0:     DROP TABLE collate4t3;
sl@0:     DROP TABLE collate4t4;
sl@0:   }
sl@0: } {}
sl@0: 
sl@0: do_test collate4-1.2.0 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t1(a COLLATE NOCASE, b COLLATE TEXT);
sl@0:     INSERT INTO collate4t1 VALUES( 'a', 'a' );
sl@0:     INSERT INTO collate4t1 VALUES( 'b', 'b' );
sl@0:     INSERT INTO collate4t1 VALUES( NULL, NULL );
sl@0:     INSERT INTO collate4t1 VALUES( 'B', 'B' );
sl@0:     INSERT INTO collate4t1 VALUES( 'A', 'A' );
sl@0:     CREATE INDEX collate4i1 ON collate4t1(a, b);
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-1.2.1 {
sl@0:   cksort {SELECT a FROM collate4t1 ORDER BY a}
sl@0: } {{} A a B b nosort}
sl@0: do_test collate4-1.2.2 {
sl@0:   cksort {SELECT a FROM collate4t1 ORDER BY a COLLATE nocase}
sl@0: } {{} A a B b nosort}
sl@0: do_test collate4-1.2.3 {
sl@0:   cksort {SELECT a FROM collate4t1 ORDER BY a COLLATE text}
sl@0: } {{} A B a b sort}
sl@0: do_test collate4-1.2.4 {
sl@0:   cksort {SELECT a FROM collate4t1 ORDER BY a, b}
sl@0: } {{} A a B b nosort}
sl@0: do_test collate4-1.2.5 {
sl@0:   cksort {SELECT a FROM collate4t1 ORDER BY a, b COLLATE nocase}
sl@0: } {{} a A b B sort}
sl@0: do_test collate4-1.2.6 {
sl@0:   cksort {SELECT a FROM collate4t1 ORDER BY a, b COLLATE text}
sl@0: } {{} A a B b nosort}
sl@0: 
sl@0: do_test collate4-1.2.7 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t2(
sl@0:       a COLLATE NOCASE, 
sl@0:       b COLLATE TEXT, 
sl@0:       PRIMARY KEY(a, b)
sl@0:     );
sl@0:     INSERT INTO collate4t2 VALUES( 'a', 'a' );
sl@0:     INSERT INTO collate4t2 VALUES( NULL, NULL );
sl@0:     INSERT INTO collate4t2 VALUES( 'B', 'B' );
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-1.2.8 {
sl@0:   cksort {SELECT a FROM collate4t2 ORDER BY a}
sl@0: } {{} a B nosort}
sl@0: do_test collate4-1.2.9 {
sl@0:   cksort {SELECT a FROM collate4t2 ORDER BY a COLLATE nocase}
sl@0: } {{} a B nosort}
sl@0: do_test collate4-1.2.10 {
sl@0:   cksort {SELECT a FROM collate4t2 ORDER BY a COLLATE text}
sl@0: } {{} B a sort}
sl@0: do_test collate4-1.2.11 {
sl@0:   cksort {SELECT a FROM collate4t2 ORDER BY a, b}
sl@0: } {{} a B nosort}
sl@0: do_test collate4-1.2.12 {
sl@0:   cksort {SELECT a FROM collate4t2 ORDER BY a, b COLLATE nocase}
sl@0: } {{} a B sort}
sl@0: do_test collate4-1.2.13 {
sl@0:   cksort {SELECT a FROM collate4t2 ORDER BY a, b COLLATE text}
sl@0: } {{} a B nosort}
sl@0: 
sl@0: do_test collate4-1.2.14 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t3(a COLLATE NOCASE, b COLLATE TEXT);
sl@0:     INSERT INTO collate4t3 VALUES( 'a', 'a' );
sl@0:     INSERT INTO collate4t3 VALUES( 'b', 'b' );
sl@0:     INSERT INTO collate4t3 VALUES( NULL, NULL );
sl@0:     INSERT INTO collate4t3 VALUES( 'B', 'B' );
sl@0:     INSERT INTO collate4t3 VALUES( 'A', 'A' );
sl@0:     CREATE INDEX collate4i2 ON collate4t3(a COLLATE TEXT, b COLLATE NOCASE);
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-1.2.15 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a}
sl@0: } {{} a A b B sort}
sl@0: do_test collate4-1.2.16 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a COLLATE nocase}
sl@0: } {{} a A b B sort}
sl@0: do_test collate4-1.2.17 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a COLLATE text}
sl@0: } {{} A B a b nosort}
sl@0: do_test collate4-1.2.18 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a COLLATE text, b}
sl@0: } {{} A B a b sort}
sl@0: do_test collate4-1.2.19 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a COLLATE text, b COLLATE nocase}
sl@0: } {{} A B a b nosort}
sl@0: do_test collate4-1.2.20 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a COLLATE text, b COLLATE text}
sl@0: } {{} A B a b sort}
sl@0: do_test collate4-1.2.21 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a COLLATE text DESC}
sl@0: } {b a B A {} nosort}
sl@0: do_test collate4-1.2.22 {
sl@0:   cksort {SELECT a FROM collate4t3 ORDER BY a COLLATE text DESC, b}
sl@0: } {b a B A {} sort}
sl@0: do_test collate4-1.2.23 {
sl@0:   cksort {SELECT a FROM collate4t3 
sl@0:             ORDER BY a COLLATE text DESC, b COLLATE nocase}
sl@0: } {b a B A {} sort}
sl@0: do_test collate4-1.2.24 {
sl@0:   cksort {SELECT a FROM collate4t3 
sl@0:             ORDER BY a COLLATE text DESC, b COLLATE nocase DESC}
sl@0: } {b a B A {} nosort}
sl@0: 
sl@0: do_test collate4-1.2.25 {
sl@0:   execsql {
sl@0:     DROP TABLE collate4t1;
sl@0:     DROP TABLE collate4t2;
sl@0:     DROP TABLE collate4t3;
sl@0:   }
sl@0: } {}
sl@0: 
sl@0: #
sl@0: # These tests - collate4-2.* - check that indices are correctly
sl@0: # selected or not selected to implement WHERE clauses when user 
sl@0: # defined collation sequences are involved. 
sl@0: #
sl@0: # Indices may optimise WHERE clauses using <, >, <=, >=, = or IN
sl@0: # operators.
sl@0: #
sl@0: do_test collate4-2.1.0 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t1(a COLLATE NOCASE);
sl@0:     CREATE TABLE collate4t2(b COLLATE TEXT);
sl@0: 
sl@0:     INSERT INTO collate4t1 VALUES('a');
sl@0:     INSERT INTO collate4t1 VALUES('A');
sl@0:     INSERT INTO collate4t1 VALUES('b');
sl@0:     INSERT INTO collate4t1 VALUES('B');
sl@0:     INSERT INTO collate4t1 VALUES('c');
sl@0:     INSERT INTO collate4t1 VALUES('C');
sl@0:     INSERT INTO collate4t1 VALUES('d');
sl@0:     INSERT INTO collate4t1 VALUES('D');
sl@0:     INSERT INTO collate4t1 VALUES('e');
sl@0:     INSERT INTO collate4t1 VALUES('D');
sl@0: 
sl@0:     INSERT INTO collate4t2 VALUES('A');
sl@0:     INSERT INTO collate4t2 VALUES('Z');
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-2.1.1 {
sl@0:   count {
sl@0:     SELECT * FROM collate4t2, collate4t1 WHERE a = b;
sl@0:   }
sl@0: } {A a A A 19}
sl@0: do_test collate4-2.1.2 {
sl@0:   execsql {
sl@0:     CREATE INDEX collate4i1 ON collate4t1(a);
sl@0:   }
sl@0:   count {
sl@0:     SELECT * FROM collate4t2, collate4t1 WHERE a = b;
sl@0:   }
sl@0: } {A a A A 5}
sl@0: do_test collate4-2.1.3 {
sl@0:   count {
sl@0:     SELECT * FROM collate4t2, collate4t1 WHERE b = a;
sl@0:   }
sl@0: } {A A 19}
sl@0: do_test collate4-2.1.4 {
sl@0:   execsql {
sl@0:     DROP INDEX collate4i1;
sl@0:     CREATE INDEX collate4i1 ON collate4t1(a COLLATE TEXT);
sl@0:   }
sl@0:   count {
sl@0:     SELECT * FROM collate4t2, collate4t1 WHERE a = b;
sl@0:   }
sl@0: } {A a A A 19}
sl@0: do_test collate4-2.1.5 {
sl@0:   count {
sl@0:     SELECT * FROM collate4t2, collate4t1 WHERE b = a;
sl@0:   }
sl@0: } {A A 4}
sl@0: ifcapable subquery {
sl@0:   do_test collate4-2.1.6 {
sl@0:     count {
sl@0:       SELECT a FROM collate4t1 WHERE a IN (SELECT * FROM collate4t2);
sl@0:     }
sl@0:   } {a A 10}
sl@0:   do_test collate4-2.1.7 {
sl@0:     execsql {
sl@0:       DROP INDEX collate4i1;
sl@0:       CREATE INDEX collate4i1 ON collate4t1(a);
sl@0:     }
sl@0:     count {
sl@0:       SELECT a FROM collate4t1 WHERE a IN (SELECT * FROM collate4t2);
sl@0:     }
sl@0:   } {a A 6}
sl@0:   do_test collate4-2.1.8 {
sl@0:     count {
sl@0:       SELECT a FROM collate4t1 WHERE a IN ('z', 'a');
sl@0:     }
sl@0:   } {a A 5}
sl@0:   do_test collate4-2.1.9 {
sl@0:     execsql {
sl@0:       DROP INDEX collate4i1;
sl@0:       CREATE INDEX collate4i1 ON collate4t1(a COLLATE TEXT);
sl@0:     }
sl@0:     count {
sl@0:       SELECT a FROM collate4t1 WHERE a IN ('z', 'a');
sl@0:     }
sl@0:   } {a A 9}
sl@0: }
sl@0: do_test collate4-2.1.10 {
sl@0:   execsql {
sl@0:     DROP TABLE collate4t1;
sl@0:     DROP TABLE collate4t2;
sl@0:   }
sl@0: } {}
sl@0: 
sl@0: do_test collate4-2.2.0 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t1(a COLLATE nocase, b COLLATE text, c);
sl@0:     CREATE TABLE collate4t2(a COLLATE nocase, b COLLATE text, c COLLATE TEXT);
sl@0: 
sl@0:     INSERT INTO collate4t1 VALUES('0', '0', '0');
sl@0:     INSERT INTO collate4t1 VALUES('0', '0', '1');
sl@0:     INSERT INTO collate4t1 VALUES('0', '1', '0');
sl@0:     INSERT INTO collate4t1 VALUES('0', '1', '1');
sl@0:     INSERT INTO collate4t1 VALUES('1', '0', '0');
sl@0:     INSERT INTO collate4t1 VALUES('1', '0', '1');
sl@0:     INSERT INTO collate4t1 VALUES('1', '1', '0');
sl@0:     INSERT INTO collate4t1 VALUES('1', '1', '1');
sl@0:     insert into collate4t2 SELECT * FROM collate4t1;
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-2.2.1 {
sl@0:   count {
sl@0:     SELECT * FROM collate4t2 NATURAL JOIN collate4t1;
sl@0:   }
sl@0: } {0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1 63}
sl@0: do_test collate4-2.2.1b {
sl@0:   execsql {
sl@0:     CREATE INDEX collate4i1 ON collate4t1(a, b, c);
sl@0:   }
sl@0:   count {
sl@0:     SELECT * FROM collate4t2 NATURAL JOIN collate4t1;
sl@0:   }
sl@0: } {0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1 29}
sl@0: do_test collate4-2.2.2 {
sl@0:   execsql {
sl@0:     DROP INDEX collate4i1;
sl@0:     CREATE INDEX collate4i1 ON collate4t1(a, b, c COLLATE text);
sl@0:   }
sl@0:   count {
sl@0:     SELECT * FROM collate4t2 NATURAL JOIN collate4t1;
sl@0:   }
sl@0: } {0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1 22}
sl@0: 
sl@0: do_test collate4-2.2.10 {
sl@0:   execsql {
sl@0:     DROP TABLE collate4t1;
sl@0:     DROP TABLE collate4t2;
sl@0:   }
sl@0: } {}
sl@0: 
sl@0: #
sl@0: # These tests - collate4-3.* verify that indices that implement
sl@0: # UNIQUE and PRIMARY KEY constraints operate correctly with user
sl@0: # defined collation sequences.
sl@0: #
sl@0: do_test collate4-3.0 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t1(a PRIMARY KEY COLLATE NOCASE);
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-3.1 {
sl@0:   catchsql {
sl@0:     INSERT INTO collate4t1 VALUES('abc');
sl@0:     INSERT INTO collate4t1 VALUES('ABC');
sl@0:   }
sl@0: } {1 {column a is not unique}}
sl@0: do_test collate4-3.2 {
sl@0:   execsql {
sl@0:     SELECT * FROM collate4t1;
sl@0:   }
sl@0: } {abc}
sl@0: do_test collate4-3.3 {
sl@0:   catchsql {
sl@0:     INSERT INTO collate4t1 SELECT upper(a) FROM collate4t1;
sl@0:   }
sl@0: } {1 {column a is not unique}}
sl@0: do_test collate4-3.4 {
sl@0:   catchsql {
sl@0:     INSERT INTO collate4t1 VALUES(1);
sl@0:     UPDATE collate4t1 SET a = 'abc';
sl@0:   }
sl@0: } {1 {column a is not unique}}
sl@0: do_test collate4-3.5 {
sl@0:   execsql {
sl@0:     DROP TABLE collate4t1;
sl@0:     CREATE TABLE collate4t1(a COLLATE NOCASE UNIQUE);
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-3.6 {
sl@0:   catchsql {
sl@0:     INSERT INTO collate4t1 VALUES('abc');
sl@0:     INSERT INTO collate4t1 VALUES('ABC');
sl@0:   }
sl@0: } {1 {column a is not unique}}
sl@0: do_test collate4-3.7 {
sl@0:   execsql {
sl@0:     SELECT * FROM collate4t1;
sl@0:   }
sl@0: } {abc}
sl@0: do_test collate4-3.8 {
sl@0:   catchsql {
sl@0:     INSERT INTO collate4t1 SELECT upper(a) FROM collate4t1;
sl@0:   }
sl@0: } {1 {column a is not unique}}
sl@0: do_test collate4-3.9 {
sl@0:   catchsql {
sl@0:     INSERT INTO collate4t1 VALUES(1);
sl@0:     UPDATE collate4t1 SET a = 'abc';
sl@0:   }
sl@0: } {1 {column a is not unique}}
sl@0: do_test collate4-3.10 {
sl@0:   execsql {
sl@0:     DROP TABLE collate4t1;
sl@0:     CREATE TABLE collate4t1(a);
sl@0:     CREATE UNIQUE INDEX collate4i1 ON collate4t1(a COLLATE NOCASE);
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-3.11 {
sl@0:   catchsql {
sl@0:     INSERT INTO collate4t1 VALUES('abc');
sl@0:     INSERT INTO collate4t1 VALUES('ABC');
sl@0:   }
sl@0: } {1 {column a is not unique}}
sl@0: do_test collate4-3.12 {
sl@0:   execsql {
sl@0:     SELECT * FROM collate4t1;
sl@0:   }
sl@0: } {abc}
sl@0: do_test collate4-3.13 {
sl@0:   catchsql {
sl@0:     INSERT INTO collate4t1 SELECT upper(a) FROM collate4t1;
sl@0:   }
sl@0: } {1 {column a is not unique}}
sl@0: do_test collate4-3.14 {
sl@0:   catchsql {
sl@0:     INSERT INTO collate4t1 VALUES(1);
sl@0:     UPDATE collate4t1 SET a = 'abc';
sl@0:   }
sl@0: } {1 {column a is not unique}}
sl@0: 
sl@0: do_test collate4-3.15 {
sl@0:   execsql {
sl@0:     DROP TABLE collate4t1;
sl@0:   }
sl@0: } {}
sl@0: 
sl@0: # Mimic the SQLite 2 collation type NUMERIC.
sl@0: db collate numeric numeric_collate
sl@0: proc numeric_collate {lhs rhs} {
sl@0:   if {$lhs == $rhs} {return 0} 
sl@0:   return [expr ($lhs>$rhs)?1:-1]
sl@0: }
sl@0: 
sl@0: #
sl@0: # These tests - collate4-4.* check that min() and max() only ever 
sl@0: # use indices constructed with built-in collation type numeric.
sl@0: #
sl@0: # CHANGED:  min() and max() now use the collation type. If there
sl@0: # is an indice that can be used, it is used.
sl@0: #
sl@0: do_test collate4-4.0 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t1(a COLLATE TEXT);
sl@0:     INSERT INTO collate4t1 VALUES('2');
sl@0:     INSERT INTO collate4t1 VALUES('10');
sl@0:     INSERT INTO collate4t1 VALUES('20');
sl@0:     INSERT INTO collate4t1 VALUES('104');
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-4.1 {
sl@0:   count {
sl@0:     SELECT max(a) FROM collate4t1
sl@0:   }
sl@0: } {20 3}
sl@0: do_test collate4-4.2 {
sl@0:   count {
sl@0:     SELECT min(a) FROM collate4t1
sl@0:   }
sl@0: } {10 3}
sl@0: do_test collate4-4.3 {
sl@0:   # Test that the index with collation type TEXT is used.
sl@0:   execsql {
sl@0:     CREATE INDEX collate4i1 ON collate4t1(a);
sl@0:   }
sl@0:   count {
sl@0:     SELECT min(a) FROM collate4t1;
sl@0:   }
sl@0: } {10 1}
sl@0: do_test collate4-4.4 {
sl@0:   count {
sl@0:     SELECT max(a) FROM collate4t1;
sl@0:   }
sl@0: } {20 0}
sl@0: do_test collate4-4.5 {
sl@0:   # Test that the index with collation type NUMERIC is not used.
sl@0:   execsql {
sl@0:     DROP INDEX collate4i1;
sl@0:     CREATE INDEX collate4i1 ON collate4t1(a COLLATE NUMERIC);
sl@0:   }
sl@0:   count {
sl@0:     SELECT min(a) FROM collate4t1;
sl@0:   }
sl@0: } {10 3}
sl@0: do_test collate4-4.6 {
sl@0:   count {
sl@0:     SELECT max(a) FROM collate4t1;
sl@0:   }
sl@0: } {20 3}
sl@0: do_test collate4-4.7 {
sl@0:   execsql {
sl@0:     DROP TABLE collate4t1;
sl@0:   }
sl@0: } {}
sl@0: 
sl@0: # Also test the scalar min() and max() functions.
sl@0: #
sl@0: do_test collate4-4.8 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t1(a COLLATE TEXT, b COLLATE NUMERIC);
sl@0:     INSERT INTO collate4t1 VALUES('11', '101');
sl@0:     INSERT INTO collate4t1 VALUES('101', '11')
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-4.9 {
sl@0:   execsql {
sl@0:     SELECT max(a, b) FROM collate4t1;
sl@0:   }
sl@0: } {11 11}
sl@0: do_test collate4-4.10 {
sl@0:   execsql {
sl@0:     SELECT max(b, a) FROM collate4t1;
sl@0:   }
sl@0: } {101 101}
sl@0: do_test collate4-4.11 {
sl@0:   execsql {
sl@0:     SELECT max(a, '101') FROM collate4t1;
sl@0:   }
sl@0: } {11 101}
sl@0: do_test collate4-4.12 {
sl@0:   execsql {
sl@0:     SELECT max('101', a) FROM collate4t1;
sl@0:   }
sl@0: } {11 101}
sl@0: do_test collate4-4.13 {
sl@0:   execsql {
sl@0:     SELECT max(b, '101') FROM collate4t1;
sl@0:   }
sl@0: } {101 101}
sl@0: do_test collate4-4.14 {
sl@0:   execsql {
sl@0:     SELECT max('101', b) FROM collate4t1;
sl@0:   }
sl@0: } {101 101}
sl@0: 
sl@0: do_test collate4-4.15 {
sl@0:   execsql {
sl@0:     DROP TABLE collate4t1;
sl@0:   }
sl@0: } {}
sl@0: 
sl@0: #
sl@0: # These tests - collate4.6.* - ensure that implict INTEGER PRIMARY KEY 
sl@0: # indices do not confuse collation sequences. 
sl@0: #
sl@0: # These indices are never used for sorting in SQLite. And you can't
sl@0: # create another index on an INTEGER PRIMARY KEY column, so we don't have 
sl@0: # to test that.
sl@0: # (Revised 2004-Nov-22):  The ROWID can be used for sorting now.
sl@0: #
sl@0: do_test collate4-6.0 {
sl@0:   execsql {
sl@0:     CREATE TABLE collate4t1(a INTEGER PRIMARY KEY);
sl@0:     INSERT INTO collate4t1 VALUES(101);
sl@0:     INSERT INTO collate4t1 VALUES(10);
sl@0:     INSERT INTO collate4t1 VALUES(15);
sl@0:   }
sl@0: } {}
sl@0: do_test collate4-6.1 {
sl@0:   cksort {
sl@0:     SELECT * FROM collate4t1 ORDER BY 1;
sl@0:   }
sl@0: } {10 15 101 nosort}
sl@0: do_test collate4-6.2 {
sl@0:   cksort {
sl@0:     SELECT * FROM collate4t1 ORDER BY oid;
sl@0:   }
sl@0: } {10 15 101 nosort}
sl@0: do_test collate4-6.3 {
sl@0:   cksort {
sl@0:     SELECT * FROM collate4t1 ORDER BY oid||'' COLLATE TEXT;
sl@0:   }
sl@0: } {10 101 15 sort}
sl@0: 
sl@0: finish_test