Annotation of embedaddon/sqlite3/test/misc1.test, revision 1.1.1.1
1.1 misho 1: # 2001 September 15.
2: #
3: # The author disclaims copyright to this source code. In place of
4: # a legal notice, here is a blessing:
5: #
6: # May you do good and not evil.
7: # May you find forgiveness for yourself and forgive others.
8: # May you share freely, never taking more than you give.
9: #
10: #***********************************************************************
11: # This file implements regression tests for SQLite library.
12: #
13: # This file implements tests for miscellanous features that were
14: # left out of other test files.
15: #
16: # $Id: misc1.test,v 1.42 2007/11/05 14:58:23 drh Exp $
17:
18: set testdir [file dirname $argv0]
19: source $testdir/tester.tcl
20:
21: # Mimic the SQLite 2 collation type NUMERIC.
22: db collate numeric numeric_collate
23: proc numeric_collate {lhs rhs} {
24: if {$lhs == $rhs} {return 0}
25: return [expr ($lhs>$rhs)?1:-1]
26: }
27:
28: # Mimic the SQLite 2 collation type TEXT.
29: db collate text text_collate
30: proc numeric_collate {lhs rhs} {
31: return [string compare $lhs $rhs]
32: }
33:
34: # Test the creation and use of tables that have a large number
35: # of columns.
36: #
37: do_test misc1-1.1 {
38: set cmd "CREATE TABLE manycol(x0 text"
39: for {set i 1} {$i<=99} {incr i} {
40: append cmd ",x$i text"
41: }
42: append cmd ")";
43: execsql $cmd
44: set cmd "INSERT INTO manycol VALUES(0"
45: for {set i 1} {$i<=99} {incr i} {
46: append cmd ",$i"
47: }
48: append cmd ")";
49: execsql $cmd
50: execsql "SELECT x99 FROM manycol"
51: } 99
52: do_test misc1-1.2 {
53: execsql {SELECT x0, x10, x25, x50, x75 FROM manycol}
54: } {0 10 25 50 75}
55: do_test misc1-1.3.1 {
56: for {set j 100} {$j<=1000} {incr j 100} {
57: set cmd "INSERT INTO manycol VALUES($j"
58: for {set i 1} {$i<=99} {incr i} {
59: append cmd ",[expr {$i+$j}]"
60: }
61: append cmd ")"
62: execsql $cmd
63: }
64: execsql {SELECT x50 FROM manycol ORDER BY x80+0}
65: } {50 150 250 350 450 550 650 750 850 950 1050}
66: do_test misc1-1.3.2 {
67: execsql {SELECT x50 FROM manycol ORDER BY x80}
68: } {1050 150 250 350 450 550 650 750 50 850 950}
69: do_test misc1-1.4 {
70: execsql {SELECT x75 FROM manycol WHERE x50=350}
71: } 375
72: do_test misc1-1.5 {
73: execsql {SELECT x50 FROM manycol WHERE x99=599}
74: } 550
75: do_test misc1-1.6 {
76: execsql {CREATE INDEX manycol_idx1 ON manycol(x99)}
77: execsql {SELECT x50 FROM manycol WHERE x99=899}
78: } 850
79: do_test misc1-1.7 {
80: execsql {SELECT count(*) FROM manycol}
81: } 11
82: do_test misc1-1.8 {
83: execsql {DELETE FROM manycol WHERE x98=1234}
84: execsql {SELECT count(*) FROM manycol}
85: } 11
86: do_test misc1-1.9 {
87: execsql {DELETE FROM manycol WHERE x98=998}
88: execsql {SELECT count(*) FROM manycol}
89: } 10
90: do_test misc1-1.10 {
91: execsql {DELETE FROM manycol WHERE x99=500}
92: execsql {SELECT count(*) FROM manycol}
93: } 10
94: do_test misc1-1.11 {
95: execsql {DELETE FROM manycol WHERE x99=599}
96: execsql {SELECT count(*) FROM manycol}
97: } 9
98:
99: # Check GROUP BY expressions that name two or more columns.
100: #
101: do_test misc1-2.1 {
102: execsql {
103: BEGIN TRANSACTION;
104: CREATE TABLE agger(one text, two text, three text, four text);
105: INSERT INTO agger VALUES(1, 'one', 'hello', 'yes');
106: INSERT INTO agger VALUES(2, 'two', 'howdy', 'no');
107: INSERT INTO agger VALUES(3, 'thr', 'howareya', 'yes');
108: INSERT INTO agger VALUES(4, 'two', 'lothere', 'yes');
109: INSERT INTO agger VALUES(5, 'one', 'atcha', 'yes');
110: INSERT INTO agger VALUES(6, 'two', 'hello', 'no');
111: COMMIT
112: }
113: execsql {SELECT count(*) FROM agger}
114: } 6
115: do_test misc1-2.2 {
116: execsql {SELECT sum(one), two, four FROM agger
117: GROUP BY two, four ORDER BY sum(one) desc}
118: } {8 two no 6 one yes 4 two yes 3 thr yes}
119: do_test misc1-2.3 {
120: execsql {SELECT sum((one)), (two), (four) FROM agger
121: GROUP BY (two), (four) ORDER BY sum(one) desc}
122: } {8 two no 6 one yes 4 two yes 3 thr yes}
123:
124: # Here's a test for a bug found by Joel Lucsy. The code below
125: # was causing an assertion failure.
126: #
127: do_test misc1-3.1 {
128: set r [execsql {
129: CREATE TABLE t1(a);
130: INSERT INTO t1 VALUES('hi');
131: PRAGMA full_column_names=on;
132: SELECT rowid, * FROM t1;
133: }]
134: lindex $r 1
135: } {hi}
136:
137: # Here's a test for yet another bug found by Joel Lucsy. The code
138: # below was causing an assertion failure.
139: #
140: do_test misc1-4.1 {
141: execsql {
142: BEGIN;
143: CREATE TABLE t2(a);
144: INSERT INTO t2 VALUES('This is a long string to use up a lot of disk -');
145: UPDATE t2 SET a=a||a||a||a;
146: INSERT INTO t2 SELECT '1 - ' || a FROM t2;
147: INSERT INTO t2 SELECT '2 - ' || a FROM t2;
148: INSERT INTO t2 SELECT '3 - ' || a FROM t2;
149: INSERT INTO t2 SELECT '4 - ' || a FROM t2;
150: INSERT INTO t2 SELECT '5 - ' || a FROM t2;
151: INSERT INTO t2 SELECT '6 - ' || a FROM t2;
152: COMMIT;
153: SELECT count(*) FROM t2;
154: }
155: } {64}
156:
157: # Make sure we actually see a semicolon or end-of-file in the SQL input
158: # before executing a command. Thus if "WHERE" is misspelled on an UPDATE,
159: # the user won't accidently update every record.
160: #
161: do_test misc1-5.1 {
162: catchsql {
163: CREATE TABLE t3(a,b);
164: INSERT INTO t3 VALUES(1,2);
165: INSERT INTO t3 VALUES(3,4);
166: UPDATE t3 SET a=0 WHEREwww b=2;
167: }
168: } {1 {near "WHEREwww": syntax error}}
169: do_test misc1-5.2 {
170: execsql {
171: SELECT * FROM t3 ORDER BY a;
172: }
173: } {1 2 3 4}
174:
175: # Certain keywords (especially non-standard keywords like "REPLACE") can
176: # also be used as identifiers. The way this works in the parser is that
177: # the parser first detects a syntax error, the error handling routine
178: # sees that the special keyword caused the error, then replaces the keyword
179: # with "ID" and tries again.
180: #
181: # Check the operation of this logic.
182: #
183: do_test misc1-6.1 {
184: catchsql {
185: CREATE TABLE t4(
186: abort, asc, begin, cluster, conflict, copy, delimiters, desc, end,
187: explain, fail, ignore, key, offset, pragma, replace, temp,
188: vacuum, view
189: );
190: }
191: } {0 {}}
192: do_test misc1-6.2 {
193: catchsql {
194: INSERT INTO t4
195: VALUES(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19);
196: }
197: } {0 {}}
198: do_test misc1-6.3 {
199: execsql {
200: SELECT * FROM t4
201: }
202: } {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19}
203: do_test misc1-6.4 {
204: execsql {
205: SELECT abort+asc,max(key,pragma,temp) FROM t4
206: }
207: } {3 17}
208:
209: # Test for multi-column primary keys, and for multiple primary keys.
210: #
211: do_test misc1-7.1 {
212: catchsql {
213: CREATE TABLE error1(
214: a TYPE PRIMARY KEY,
215: b TYPE PRIMARY KEY
216: );
217: }
218: } {1 {table "error1" has more than one primary key}}
219: do_test misc1-7.2 {
220: catchsql {
221: CREATE TABLE error1(
222: a INTEGER PRIMARY KEY,
223: b TYPE PRIMARY KEY
224: );
225: }
226: } {1 {table "error1" has more than one primary key}}
227: do_test misc1-7.3 {
228: execsql {
229: CREATE TABLE t5(a,b,c,PRIMARY KEY(a,b));
230: INSERT INTO t5 VALUES(1,2,3);
231: SELECT * FROM t5 ORDER BY a;
232: }
233: } {1 2 3}
234: do_test misc1-7.4 {
235: catchsql {
236: INSERT INTO t5 VALUES(1,2,4);
237: }
238: } {1 {columns a, b are not unique}}
239: do_test misc1-7.5 {
240: catchsql {
241: INSERT INTO t5 VALUES(0,2,4);
242: }
243: } {0 {}}
244: do_test misc1-7.6 {
245: execsql {
246: SELECT * FROM t5 ORDER BY a;
247: }
248: } {0 2 4 1 2 3}
249:
250: do_test misc1-8.1 {
251: catchsql {
252: SELECT *;
253: }
254: } {1 {no tables specified}}
255: do_test misc1-8.2 {
256: catchsql {
257: SELECT t1.*;
258: }
259: } {1 {no such table: t1}}
260:
261: execsql {
262: DROP TABLE t1;
263: DROP TABLE t2;
264: DROP TABLE t3;
265: DROP TABLE t4;
266: }
267:
268: # 64-bit integers are represented exactly.
269: #
270: do_test misc1-9.1 {
271: catchsql {
272: CREATE TABLE t1(a unique not null, b unique not null);
273: INSERT INTO t1 VALUES('a',1234567890123456789);
274: INSERT INTO t1 VALUES('b',1234567891123456789);
275: INSERT INTO t1 VALUES('c',1234567892123456789);
276: SELECT * FROM t1;
277: }
278: } {0 {a 1234567890123456789 b 1234567891123456789 c 1234567892123456789}}
279:
280: # A WHERE clause is not allowed to contain more than 99 terms. Check to
281: # make sure this limit is enforced.
282: #
283: # 2005-07-16: There is no longer a limit on the number of terms in a
284: # WHERE clause. But keep these tests just so that we have some tests
285: # that use a large number of terms in the WHERE clause.
286: #
287: do_test misc1-10.0 {
288: execsql {SELECT count(*) FROM manycol}
289: } {9}
290: do_test misc1-10.1 {
291: set ::where {WHERE x0>=0}
292: for {set i 1} {$i<=99} {incr i} {
293: append ::where " AND x$i<>0"
294: }
295: catchsql "SELECT count(*) FROM manycol $::where"
296: } {0 9}
297: do_test misc1-10.2 {
298: catchsql "SELECT count(*) FROM manycol $::where AND rowid>0"
299: } {0 9}
300: do_test misc1-10.3 {
301: regsub "x0>=0" $::where "x0=0" ::where
302: catchsql "DELETE FROM manycol $::where"
303: } {0 {}}
304: do_test misc1-10.4 {
305: execsql {SELECT count(*) FROM manycol}
306: } {8}
307: do_test misc1-10.5 {
308: catchsql "DELETE FROM manycol $::where AND rowid>0"
309: } {0 {}}
310: do_test misc1-10.6 {
311: execsql {SELECT x1 FROM manycol WHERE x0=100}
312: } {101}
313: do_test misc1-10.7 {
314: regsub "x0=0" $::where "x0=100" ::where
315: catchsql "UPDATE manycol SET x1=x1+1 $::where"
316: } {0 {}}
317: do_test misc1-10.8 {
318: execsql {SELECT x1 FROM manycol WHERE x0=100}
319: } {102}
320: do_test misc1-10.9 {
321: catchsql "UPDATE manycol SET x1=x1+1 $::where AND rowid>0"
322: } {0 {}}
323: do_test misc1-10.10 {
324: execsql {SELECT x1 FROM manycol WHERE x0=100}
325: } {103}
326:
327: # Make sure the initialization works even if a database is opened while
328: # another process has the database locked.
329: #
330: # Update for v3: The BEGIN doesn't lock the database so the schema is read
331: # and the SELECT returns successfully.
332: do_test misc1-11.1 {
333: execsql {BEGIN}
334: execsql {UPDATE t1 SET a=0 WHERE 0}
335: sqlite3 db2 test.db
336: set rc [catch {db2 eval {SELECT count(*) FROM t1}} msg]
337: lappend rc $msg
338: # v2 result: {1 {database is locked}}
339: } {0 3}
340: do_test misc1-11.2 {
341: execsql {COMMIT}
342: set rc [catch {db2 eval {SELECT count(*) FROM t1}} msg]
343: db2 close
344: lappend rc $msg
345: } {0 3}
346:
347: # Make sure string comparisons really do compare strings in format4+.
348: # Similar tests in the format3.test file show that for format3 and earlier
349: # all comparisions where numeric if either operand looked like a number.
350: #
351: do_test misc1-12.1 {
352: execsql {SELECT '0'=='0.0'}
353: } {0}
354: do_test misc1-12.2 {
355: execsql {SELECT '0'==0.0}
356: } {0}
357: do_test misc1-12.3 {
358: execsql {SELECT '12345678901234567890'=='12345678901234567891'}
359: } {0}
360: do_test misc1-12.4 {
361: execsql {
362: CREATE TABLE t6(a INT UNIQUE, b TEXT UNIQUE);
363: INSERT INTO t6 VALUES('0','0.0');
364: SELECT * FROM t6;
365: }
366: } {0 0.0}
367: ifcapable conflict {
368: do_test misc1-12.5 {
369: execsql {
370: INSERT OR IGNORE INTO t6 VALUES(0.0,'x');
371: SELECT * FROM t6;
372: }
373: } {0 0.0}
374: do_test misc1-12.6 {
375: execsql {
376: INSERT OR IGNORE INTO t6 VALUES('y',0);
377: SELECT * FROM t6;
378: }
379: } {0 0.0 y 0}
380: }
381: do_test misc1-12.7 {
382: execsql {
383: CREATE TABLE t7(x INTEGER, y TEXT, z);
384: INSERT INTO t7 VALUES(0,0,1);
385: INSERT INTO t7 VALUES(0.0,0,2);
386: INSERT INTO t7 VALUES(0,0.0,3);
387: INSERT INTO t7 VALUES(0.0,0.0,4);
388: SELECT DISTINCT x, y FROM t7 ORDER BY z;
389: }
390: } {0 0 0 0.0}
391: do_test misc1-12.8 {
392: execsql {
393: SELECT min(z), max(z), count(z) FROM t7 GROUP BY x ORDER BY 1;
394: }
395: } {1 4 4}
396: do_test misc1-12.9 {
397: execsql {
398: SELECT min(z), max(z), count(z) FROM t7 GROUP BY y ORDER BY 1;
399: }
400: } {1 2 2 3 4 2}
401:
402: # This used to be an error. But we changed the code so that arbitrary
403: # identifiers can be used as a collating sequence. Collation is by text
404: # if the identifier contains "text", "blob", or "clob" and is numeric
405: # otherwise.
406: #
407: # Update: In v3, it is an error again.
408: #
409: #do_test misc1-12.10 {
410: # catchsql {
411: # SELECT * FROM t6 ORDER BY a COLLATE unknown;
412: # }
413: #} {0 {0 0 y 0}}
414: do_test misc1-12.11 {
415: execsql {
416: CREATE TABLE t8(x TEXT COLLATE numeric, y INTEGER COLLATE text, z);
417: INSERT INTO t8 VALUES(0,0,1);
418: INSERT INTO t8 VALUES(0.0,0,2);
419: INSERT INTO t8 VALUES(0,0.0,3);
420: INSERT INTO t8 VALUES(0.0,0.0,4);
421: SELECT DISTINCT x, y FROM t8 ORDER BY z;
422: }
423: } {0 0 0.0 0}
424: do_test misc1-12.12 {
425: execsql {
426: SELECT min(z), max(z), count(z) FROM t8 GROUP BY x ORDER BY 1;
427: }
428: } {1 3 2 2 4 2}
429: do_test misc1-12.13 {
430: execsql {
431: SELECT min(z), max(z), count(z) FROM t8 GROUP BY y ORDER BY 1;
432: }
433: } {1 4 4}
434:
435: # There was a problem with realloc() in the OP_MemStore operation of
436: # the VDBE. A buffer was being reallocated but some pointers into
437: # the old copy of the buffer were not being moved over to the new copy.
438: # The following code tests for the problem.
439: #
440: ifcapable subquery {
441: do_test misc1-13.1 {
442: execsql {
443: CREATE TABLE t9(x,y);
444: INSERT INTO t9 VALUES('one',1);
445: INSERT INTO t9 VALUES('two',2);
446: INSERT INTO t9 VALUES('three',3);
447: INSERT INTO t9 VALUES('four',4);
448: INSERT INTO t9 VALUES('five',5);
449: INSERT INTO t9 VALUES('six',6);
450: INSERT INTO t9 VALUES('seven',7);
451: INSERT INTO t9 VALUES('eight',8);
452: INSERT INTO t9 VALUES('nine',9);
453: INSERT INTO t9 VALUES('ten',10);
454: INSERT INTO t9 VALUES('eleven',11);
455: SELECT y FROM t9
456: WHERE x=(SELECT x FROM t9 WHERE y=1)
457: OR x=(SELECT x FROM t9 WHERE y=2)
458: OR x=(SELECT x FROM t9 WHERE y=3)
459: OR x=(SELECT x FROM t9 WHERE y=4)
460: OR x=(SELECT x FROM t9 WHERE y=5)
461: OR x=(SELECT x FROM t9 WHERE y=6)
462: OR x=(SELECT x FROM t9 WHERE y=7)
463: OR x=(SELECT x FROM t9 WHERE y=8)
464: OR x=(SELECT x FROM t9 WHERE y=9)
465: OR x=(SELECT x FROM t9 WHERE y=10)
466: OR x=(SELECT x FROM t9 WHERE y=11)
467: OR x=(SELECT x FROM t9 WHERE y=12)
468: OR x=(SELECT x FROM t9 WHERE y=13)
469: OR x=(SELECT x FROM t9 WHERE y=14)
470: ;
471: }
472: } {1 2 3 4 5 6 7 8 9 10 11}
473: }
474:
475: # Make sure a database connection still works after changing the
476: # working directory.
477: #
478: do_test misc1-14.1 {
479: file mkdir tempdir
480: cd tempdir
481: execsql {BEGIN}
482: file exists ./test.db-journal
483: } {0}
484: do_test misc1-14.2a {
485: execsql {UPDATE t1 SET a=a||'x' WHERE 0}
486: file exists ../test.db-journal
487: } {0}
488: do_test misc1-14.2b {
489: execsql {UPDATE t1 SET a=a||'y' WHERE 1}
490: file exists ../test.db-journal
491: } {1}
492: do_test misc1-14.3 {
493: cd ..
494: forcedelete tempdir
495: execsql {COMMIT}
496: file exists ./test.db-journal
497: } {0}
498:
499: # A failed create table should not leave the table in the internal
500: # data structures. Ticket #238.
501: #
502: do_test misc1-15.1.1 {
503: catchsql {
504: CREATE TABLE t10 AS SELECT c1;
505: }
506: } {1 {no such column: c1}}
507: do_test misc1-15.1.2 {
508: catchsql {
509: CREATE TABLE t10 AS SELECT t9.c1;
510: }
511: } {1 {no such column: t9.c1}}
512: do_test misc1-15.1.3 {
513: catchsql {
514: CREATE TABLE t10 AS SELECT main.t9.c1;
515: }
516: } {1 {no such column: main.t9.c1}}
517: do_test misc1-15.2 {
518: catchsql {
519: CREATE TABLE t10 AS SELECT 1;
520: }
521: # The bug in ticket #238 causes the statement above to fail with
522: # the error "table t10 alread exists"
523: } {0 {}}
524:
525: # Test for memory leaks when a CREATE TABLE containing a primary key
526: # fails. Ticket #249.
527: #
528: do_test misc1-16.1 {
529: catchsql {SELECT name FROM sqlite_master LIMIT 1}
530: catchsql {
531: CREATE TABLE test(a integer, primary key(a));
532: }
533: } {0 {}}
534: do_test misc1-16.2 {
535: catchsql {
536: CREATE TABLE test(a integer, primary key(a));
537: }
538: } {1 {table test already exists}}
539: do_test misc1-16.3 {
540: catchsql {
541: CREATE TABLE test2(a text primary key, b text, primary key(a,b));
542: }
543: } {1 {table "test2" has more than one primary key}}
544: do_test misc1-16.4 {
545: execsql {
546: INSERT INTO test VALUES(1);
547: SELECT rowid, a FROM test;
548: }
549: } {1 1}
550: do_test misc1-16.5 {
551: execsql {
552: INSERT INTO test VALUES(5);
553: SELECT rowid, a FROM test;
554: }
555: } {1 1 5 5}
556: do_test misc1-16.6 {
557: execsql {
558: INSERT INTO test VALUES(NULL);
559: SELECT rowid, a FROM test;
560: }
561: } {1 1 5 5 6 6}
562:
563: ifcapable trigger&&tempdb {
564: # Ticket #333: Temp triggers that modify persistent tables.
565: #
566: do_test misc1-17.1 {
567: execsql {
568: BEGIN;
569: CREATE TABLE RealTable(TestID INTEGER PRIMARY KEY, TestString TEXT);
570: CREATE TEMP TABLE TempTable(TestID INTEGER PRIMARY KEY, TestString TEXT);
571: CREATE TEMP TRIGGER trigTest_1 AFTER UPDATE ON TempTable BEGIN
572: INSERT INTO RealTable(TestString)
573: SELECT new.TestString FROM TempTable LIMIT 1;
574: END;
575: INSERT INTO TempTable(TestString) VALUES ('1');
576: INSERT INTO TempTable(TestString) VALUES ('2');
577: UPDATE TempTable SET TestString = TestString + 1 WHERE TestID=1 OR TestId=2;
578: COMMIT;
579: SELECT TestString FROM RealTable ORDER BY 1;
580: }
581: } {2 3}
582: }
583:
584: do_test misc1-18.1 {
585: set n [sqlite3_sleep 100]
586: expr {$n>=100}
587: } {1}
588:
589: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to misc1.test CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test