# 2001 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. # #*********************************************************************** # This file implements regression tests for SQLite library. # # This file implements tests for miscellanous features that were # left out of other test files. # # $Id: misc1.test,v 1.14 2002/08/18 22:41:22 drh Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl # Test the creation and use of tables that have a large number # of columns. # do_test misc1-1.1 { set cmd "CREATE TABLE manycol(x0 text" for {set i 1} {$i<=99} {incr i} { append cmd ",x$i text" } append cmd ")"; execsql $cmd set cmd "INSERT INTO manycol VALUES(0" for {set i 1} {$i<=99} {incr i} { append cmd ",$i" } append cmd ")"; execsql $cmd execsql "SELECT x99 FROM manycol" } 99 do_test misc1-1.2 { execsql {SELECT x0, x10, x25, x50, x75 FROM manycol} } {0 10 25 50 75} do_test misc1-1.3.1 { for {set j 100} {$j<=1000} {incr j 100} { set cmd "INSERT INTO manycol VALUES($j" for {set i 1} {$i<=99} {incr i} { append cmd ",[expr {$i+$j}]" } append cmd ")" execsql $cmd } execsql {SELECT x50 FROM manycol ORDER BY x80+0} } {50 150 250 350 450 550 650 750 850 950 1050} do_test misc1-1.3.2 { execsql {SELECT x50 FROM manycol ORDER BY x80} } {1050 150 250 350 450 550 650 750 50 850 950} do_test misc1-1.4 { execsql {SELECT x75 FROM manycol WHERE x50=350} } 375 do_test misc1-1.5 { execsql {SELECT x50 FROM manycol WHERE x99=599} } 550 do_test misc1-1.6 { execsql {CREATE INDEX manycol_idx1 ON manycol(x99)} execsql {SELECT x50 FROM manycol WHERE x99=899} } 850 do_test misc1-1.7 { execsql {SELECT count(*) FROM manycol} } 11 do_test misc1-1.8 { execsql {DELETE FROM manycol WHERE x98=1234} execsql {SELECT count(*) FROM manycol} } 11 do_test misc1-1.9 { execsql {DELETE FROM manycol WHERE x98=998} execsql {SELECT count(*) FROM manycol} } 10 do_test misc1-1.10 { execsql {DELETE FROM manycol WHERE x99=500} execsql {SELECT count(*) FROM manycol} } 10 do_test misc1-1.11 { execsql {DELETE FROM manycol WHERE x99=599} execsql {SELECT count(*) FROM manycol} } 9 # Check GROUP BY expressions that name two or more columns. # do_test misc1-2.1 { execsql { BEGIN TRANSACTION; CREATE TABLE agger(one text, two text, three text, four text); INSERT INTO agger VALUES(1, 'one', 'hello', 'yes'); INSERT INTO agger VALUES(2, 'two', 'howdy', 'no'); INSERT INTO agger VALUES(3, 'thr', 'howareya', 'yes'); INSERT INTO agger VALUES(4, 'two', 'lothere', 'yes'); INSERT INTO agger VALUES(5, 'one', 'atcha', 'yes'); INSERT INTO agger VALUES(6, 'two', 'hello', 'no'); COMMIT } execsql {SELECT count(*) FROM agger} } 6 do_test misc1-2.2 { execsql {SELECT sum(one), two, four FROM agger GROUP BY two, four ORDER BY sum(one) desc} } {8 two no 6 one yes 4 two yes 3 thr yes} # Here's a test for a bug found by Joel Lucsy. The code below # was causing an assertion failure. # do_test misc1-3.1 { set r [execsql { CREATE TABLE t1(a); INSERT INTO t1 VALUES('hi'); PRAGMA full_column_names=on; SELECT rowid, * FROM t1; }] lindex $r 1 } {hi} # Here's a test for yet another bug found by Joel Lucsy. The code # below was causing an assertion failure. # do_test misc1-4.1 { execsql { BEGIN; CREATE TABLE t2(a); INSERT INTO t2 VALUES('This is a long string to use up a lot of disk -'); UPDATE t2 SET a=a||a||a||a; INSERT INTO t2 SELECT '1 - ' || a FROM t2; INSERT INTO t2 SELECT '2 - ' || a FROM t2; INSERT INTO t2 SELECT '3 - ' || a FROM t2; INSERT INTO t2 SELECT '4 - ' || a FROM t2; INSERT INTO t2 SELECT '5 - ' || a FROM t2; INSERT INTO t2 SELECT '6 - ' || a FROM t2; COMMIT; SELECT count(*) FROM t2; } } {64} # Make sure we actually see a semicolon or end-of-file in the SQL input # before executing a command. Thus if "WHERE" is misspelled on an UPDATE, # the user won't accidently update every record. # do_test misc1-5.1 { catchsql { CREATE TABLE t3(a,b); INSERT INTO t3 VALUES(1,2); INSERT INTO t3 VALUES(3,4); UPDATE t3 SET a=0 WHEREwww b=2; } } {1 {near "WHEREwww": syntax error}} do_test misc1-5.2 { execsql { SELECT * FROM t3 ORDER BY a; } } {1 2 3 4} # Certain keywords (especially non-standard keywords like "REPLACE") can # also be used as identifiers. The way this works in the parser is that # the parser first detects a syntax error, the error handling routine # sees that the special keyword caused the error, then replaces the keyword # with "ID" and tries again. # # Check the operation of this logic. # do_test misc1-6.1 { catchsql { CREATE TABLE t4( abort, asc, begin, cluster, conflict, copy, delimiters, desc, end, explain, fail, ignore, key, offset, pragma, replace, temp, vacuum, view ); } } {0 {}} do_test misc1-6.2 { catchsql { INSERT INTO t4 VALUES(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19); } } {0 {}} do_test misc1-6.3 { execsql { SELECT * FROM t4 } } {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19} do_test misc1-6.4 { execsql { SELECT abort+asc,max(key,pragma,temp) FROM t4 } } {3 17} # Test for multi-column primary keys, and for multiple primary keys. # do_test misc1-7.1 { catchsql { CREATE TABLE error1( a TYPE PRIMARY KEY, b TYPE PRIMARY KEY ); } } {1 {table "error1" has more than one primary key}} do_test misc1-7.2 { catchsql { CREATE TABLE error1( a INTEGER PRIMARY KEY, b TYPE PRIMARY KEY ); } } {1 {table "error1" has more than one primary key}} do_test misc1-7.3 { execsql { CREATE TABLE t5(a,b,c,PRIMARY KEY(a,b)); INSERT INTO t5 VALUES(1,2,3); SELECT * FROM t5 ORDER BY a; } } {1 2 3} do_test misc1-7.4 { catchsql { INSERT INTO t5 VALUES(1,2,4); } } {1 {constraint failed}} do_test misc1-7.5 { catchsql { INSERT INTO t5 VALUES(0,2,4); } } {0 {}} do_test misc1-7.6 { execsql { SELECT * FROM t5 ORDER BY a; } } {0 2 4 1 2 3} do_test misc1-8.1 { catchsql { SELECT *; } } {1 {no tables specified}} do_test misc1-8.2 { catchsql { SELECT t1.*; } } {1 {no such table: t1}} execsql { DROP TABLE t1; DROP TABLE t2; DROP TABLE t3; DROP TABLE t4; } # If an integer is too big to be represented as a 32-bit machine integer, # then treat it as a string. # do_test misc1-9.1 { catchsql { CREATE TABLE t1(a unique not null, b unique not null); INSERT INTO t1 VALUES('a',12345678901234567890); INSERT INTO t1 VALUES('b',12345678911234567890); INSERT INTO t1 VALUES('c',12345678921234567890); SELECT * FROM t1; } } {0 {a 12345678901234567890 b 12345678911234567890 c 12345678921234567890}} # A WHERE clause is not allowed to contain more than 99 terms. Check to # make sure this limit is enforced. # do_test misc1-10.0 { execsql {SELECT count(*) FROM manycol} } {9} do_test misc1-10.1 { set ::where {WHERE x0>=0} for {set i 1} {$i<=99} {incr i} { append ::where " AND x$i<>0" } catchsql "SELECT count(*) FROM manycol $::where" } {0 9} do_test misc1-10.2 { catchsql "SELECT count(*) FROM manycol $::where AND rowid>0" } {1 {WHERE clause too complex - no more than 100 terms allowed}} do_test misc1-10.3 { regsub "x0>=0" $::where "x0=0" ::where catchsql "DELETE FROM manycol $::where" } {0 {}} do_test misc1-10.4 { execsql {SELECT count(*) FROM manycol} } {8} do_test misc1-10.5 { catchsql "DELETE FROM manycol $::where AND rowid>0" } {1 {WHERE clause too complex - no more than 100 terms allowed}} do_test misc1-10.6 { execsql {SELECT x1 FROM manycol WHERE x0=100} } {101} do_test misc1-10.7 { regsub "x0=0" $::where "x0=100" ::where catchsql "UPDATE manycol SET x1=x1+1 $::where" } {0 {}} do_test misc1-10.8 { execsql {SELECT x1 FROM manycol WHERE x0=100} } {102} do_test misc1-10.9 { catchsql "UPDATE manycol SET x1=x1+1 $::where AND rowid>0" } {1 {WHERE clause too complex - no more than 100 terms allowed}} do_test misc1-10.10 { execsql {SELECT x1 FROM manycol WHERE x0=100} } {102} # Make sure the initialization works even if a database is opened while # another process has the database locked. # do_test misc1-11.1 { execsql {BEGIN} sqlite db2 test.db set rc [catch {db2 eval {SELECT count(*) FROM t1}} msg] lappend rc $msg } {1 {database is locked}} do_test misc1-11.2 { execsql {COMMIT} set rc [catch {db2 eval {SELECT count(*) FROM t1}} msg] db2 close lappend rc $msg } {0 3} # Make sure string comparisons really do compare strings in format4+. # Similar tests in the format3.test file show that for format3 and earlier # all comparisions where numeric if either operand looked like a number. # do_test misc1-12.1 { execsql {SELECT '0'=='0.0'} } {0} do_test misc1-12.2 { execsql {SELECT '0'==0.0} } {1} do_test misc1-12.3 { execsql {SELECT '12345678901234567890'=='12345678901234567891'} } {0} do_test misc1-12.4 { execsql { CREATE TABLE t6(a INT UNIQUE, b TEXT UNIQUE); INSERT INTO t6 VALUES('0','0.0'); SELECT * FROM t6; } } {0 0.0} do_test misc1-12.5 { execsql { INSERT OR IGNORE INTO t6 VALUES(0.0,'x'); SELECT * FROM t6; } } {0 0.0} do_test misc1-12.6 { execsql { INSERT OR IGNORE INTO t6 VALUES('y',0); SELECT * FROM t6; } } {0 0.0 y 0} do_test misc1-12.7 { execsql { CREATE TABLE t7(x INTEGER, y TEXT, z); INSERT INTO t7 VALUES(0,0,1); INSERT INTO t7 VALUES(0.0,0,2); INSERT INTO t7 VALUES(0,0.0,3); INSERT INTO t7 VALUES(0.0,0.0,4); SELECT DISTINCT x, y FROM t7 ORDER BY z; } } {0 0 0 0.0} do_test misc1-12.8 { execsql { SELECT min(z), max(z), count(z) FROM t7 GROUP BY x ORDER BY 1; } } {1 4 4} do_test misc1-12.9 { execsql { SELECT min(z), max(z), count(z) FROM t7 GROUP BY y ORDER BY 1; } } {1 2 2 3 4 2} do_test misc1-12.10 { catchsql { SELECT * FROM t6 ORDER BY a COLLATE unknown; } } {1 {unknown collating type: unknown}} do_test misc1-12.11 { execsql { CREATE TABLE t8(x TEXT COLLATE numeric, y INTEGER COLLATE text, z); INSERT INTO t8 VALUES(0,0,1); INSERT INTO t8 VALUES(0.0,0,2); INSERT INTO t8 VALUES(0,0.0,3); INSERT INTO t8 VALUES(0.0,0.0,4); SELECT DISTINCT x, y FROM t8 ORDER BY z; } } {0 0 0 0.0} do_test misc1-12.12 { execsql { SELECT min(z), max(z), count(z) FROM t8 GROUP BY x ORDER BY 1; } } {1 4 4} do_test misc1-12.13 { execsql { SELECT min(z), max(z), count(z) FROM t8 GROUP BY y ORDER BY 1; } } {1 2 2 3 4 2} finish_test