1: # 2003 January 29
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. The
12: # focus of this script testing the callback-free C/C++ API.
13: #
14: # $Id: capi3.test,v 1.1.1.1 2012/02/21 17:04:16 misho Exp $
15: #
16:
17: set testdir [file dirname $argv0]
18: source $testdir/tester.tcl
19:
20: # Do not use a codec for tests in this file, as the database file is
21: # manipulated directly using tcl scripts (using the [hexio_write] command).
22: #
23: do_not_use_codec
24:
25: # Return the UTF-16 representation of the supplied UTF-8 string $str.
26: # If $nt is true, append two 0x00 bytes as a nul terminator.
27: proc utf16 {str {nt 1}} {
28: set r [encoding convertto unicode $str]
29: if {$nt} {
30: append r "\x00\x00"
31: }
32: return $r
33: }
34:
35: # Return the UTF-8 representation of the supplied UTF-16 string $str.
36: proc utf8 {str} {
37: # If $str ends in two 0x00 0x00 bytes, knock these off before
38: # converting to UTF-8 using TCL.
39: binary scan $str \c* vals
40: if {[lindex $vals end]==0 && [lindex $vals end-1]==0} {
41: set str [binary format \c* [lrange $vals 0 end-2]]
42: }
43:
44: set r [encoding convertfrom unicode $str]
45: return $r
46: }
47:
48: # These tests complement those in capi2.test. They are organized
49: # as follows:
50: #
51: # capi3-1.*: Test sqlite3_prepare
52: # capi3-2.*: Test sqlite3_prepare16
53: # capi3-3.*: Test sqlite3_open
54: # capi3-4.*: Test sqlite3_open16
55: # capi3-5.*: Test the various sqlite3_result_* APIs
56: # capi3-6.*: Test that sqlite3_close fails if there are outstanding VMs.
57: #
58:
59: set DB [sqlite3_connection_pointer db]
60:
61: do_test capi3-1.0 {
62: sqlite3_get_autocommit $DB
63: } 1
64: do_test capi3-1.1 {
65: set STMT [sqlite3_prepare $DB {SELECT name FROM sqlite_master} -1 TAIL]
66: sqlite3_finalize $STMT
67: set TAIL
68: } {}
69: do_test capi3-1.2.1 {
70: sqlite3_errcode $DB
71: } {SQLITE_OK}
72: do_test capi3-1.2.2 {
73: sqlite3_extended_errcode $DB
74: } {SQLITE_OK}
75: do_test capi3-1.3 {
76: sqlite3_errmsg $DB
77: } {not an error}
78: do_test capi3-1.4 {
79: set sql {SELECT name FROM sqlite_master;SELECT 10}
80: set STMT [sqlite3_prepare $DB $sql -1 TAIL]
81: sqlite3_finalize $STMT
82: set TAIL
83: } {SELECT 10}
84: do_test capi3-1.5 {
85: set sql {SELECT name FROM sqlite_master;SELECT 10}
86: set STMT [sqlite3_prepare $DB $sql [string length $sql] TAIL]
87: sqlite3_finalize $STMT
88: set TAIL
89: } {SELECT 10}
90: do_test capi3-1.6 {
91: set sql {SELECT name FROM sqlite_master;SELECT 10}
92: set STMT [sqlite3_prepare $DB $sql [expr [string length $sql]+1] TAIL]
93: sqlite3_finalize $STMT
94: set TAIL
95: } {SELECT 10}
96:
97: do_test capi3-1.7 {
98: set sql {SELECT namex FROM sqlite_master}
99: catch {
100: set STMT [sqlite3_prepare $DB $sql -1 TAIL]
101: }
102: } {1}
103: do_test capi3-1.8.1 {
104: sqlite3_errcode $DB
105: } {SQLITE_ERROR}
106: do_test capi3-1.8.2 {
107: sqlite3_extended_errcode $DB
108: } {SQLITE_ERROR}
109: do_test capi3-1.9 {
110: sqlite3_errmsg $DB
111: } {no such column: namex}
112:
113: ifcapable {utf16} {
114: do_test capi3-2.1 {
115: set sql16 [utf16 {SELECT name FROM sqlite_master}]
116: set STMT [sqlite3_prepare16 $DB $sql16 -1 ::TAIL]
117: sqlite3_finalize $STMT
118: utf8 $::TAIL
119: } {}
120: do_test capi3-2.2 {
121: set sql [utf16 {SELECT name FROM sqlite_master;SELECT 10}]
122: set STMT [sqlite3_prepare16 $DB $sql -1 TAIL]
123: sqlite3_finalize $STMT
124: utf8 $TAIL
125: } {SELECT 10}
126: do_test capi3-2.3 {
127: set sql [utf16 {SELECT namex FROM sqlite_master}]
128: catch {
129: set STMT [sqlite3_prepare16 $DB $sql -1]
130: }
131: } {1}
132: do_test capi3-2.4.1 {
133: sqlite3_errcode $DB
134: } {SQLITE_ERROR}
135: do_test capi3-2.4.2 {
136: sqlite3_extended_errcode $DB
137: } {SQLITE_ERROR}
138: do_test capi3-2.5 {
139: sqlite3_errmsg $DB
140: } {no such column: namex}
141:
142: ifcapable schema_pragmas {
143: do_test capi3-2.6 {
144: execsql {CREATE TABLE tablename(x)}
145: set sql16 [utf16 {PRAGMA table_info("TableName"); --excess text}]
146: set STMT [sqlite3_prepare16 $DB $sql16 -1]
147: sqlite3_step $STMT
148: } SQLITE_ROW
149: do_test capi3-2.7 {
150: sqlite3_step $STMT
151: } SQLITE_DONE
152: do_test capi3-2.8 {
153: sqlite3_finalize $STMT
154: } SQLITE_OK
155: }
156:
157: } ;# endif utf16
158:
159: # rename sqlite3_open sqlite3_open_old
160: # proc sqlite3_open {fname options} {sqlite3_open_new $fname $options}
161:
162: do_test capi3-3.1 {
163: set db2 [sqlite3_open test.db {}]
164: sqlite3_errcode $db2
165: } {SQLITE_OK}
166: # FIX ME: Should test the db handle works.
167: do_test capi3-3.2 {
168: sqlite3_close $db2
169: } {SQLITE_OK}
170: do_test capi3-3.3 {
171: catch {
172: set db2 [sqlite3_open /bogus/path/test.db {}]
173: }
174: sqlite3_extended_errcode $db2
175: } {SQLITE_CANTOPEN}
176: do_test capi3-3.4 {
177: sqlite3_errmsg $db2
178: } {unable to open database file}
179: do_test capi3-3.5 {
180: sqlite3_close $db2
181: } {SQLITE_OK}
182: do_test capi3-3.6.1-misuse {
183: sqlite3_close $db2
184: } {SQLITE_MISUSE}
185: do_test capi3-3.6.2-misuse {
186: sqlite3_errmsg $db2
187: } {library routine called out of sequence}
188: ifcapable {utf16} {
189: do_test capi3-3.6.3-misuse {
190: utf8 [sqlite3_errmsg16 $db2]
191: } {library routine called out of sequence}
192: }
193:
194: do_test capi3-3.7 {
195: set db2 [sqlite3_open]
196: sqlite3_errcode $db2
197: } {SQLITE_OK}
198: do_test capi3-3.8 {
199: sqlite3_close $db2
200: } {SQLITE_OK}
201:
202: # rename sqlite3_open ""
203: # rename sqlite3_open_old sqlite3_open
204:
205: ifcapable {utf16} {
206: do_test capi3-4.1 {
207: set db2 [sqlite3_open16 [utf16 test.db] {}]
208: sqlite3_errcode $db2
209: } {SQLITE_OK}
210: # FIX ME: Should test the db handle works.
211: do_test capi3-4.2 {
212: sqlite3_close $db2
213: } {SQLITE_OK}
214: do_test capi3-4.3 {
215: catch {
216: set db2 [sqlite3_open16 [utf16 /bogus/path/test.db] {}]
217: }
218: sqlite3_errcode $db2
219: } {SQLITE_CANTOPEN}
220: do_test capi3-4.4 {
221: utf8 [sqlite3_errmsg16 $db2]
222: } {unable to open database file}
223: do_test capi3-4.5 {
224: sqlite3_close $db2
225: } {SQLITE_OK}
226: } ;# utf16
227:
228: # This proc is used to test the following API calls:
229: #
230: # sqlite3_column_count
231: # sqlite3_column_name
232: # sqlite3_column_name16
233: # sqlite3_column_decltype
234: # sqlite3_column_decltype16
235: #
236: # $STMT is a compiled SQL statement. $test is a prefix
237: # to use for test names within this proc. $names is a list
238: # of the column names that should be returned by $STMT.
239: # $decltypes is a list of column declaration types for $STMT.
240: #
241: # Example:
242: #
243: # set STMT [sqlite3_prepare "SELECT 1, 2, 2;" -1 DUMMY]
244: # check_header test1.1 {1 2 3} {"" "" ""}
245: #
246: proc check_header {STMT test names decltypes} {
247:
248: # Use the return value of sqlite3_column_count() to build
249: # a list of column indexes. i.e. If sqlite3_column_count
250: # is 3, build the list {0 1 2}.
251: set ::idxlist [list]
252: set ::numcols [sqlite3_column_count $STMT]
253: for {set i 0} {$i < $::numcols} {incr i} {lappend ::idxlist $i}
254:
255: # Column names in UTF-8
256: do_test $test.1 {
257: set cnamelist [list]
258: foreach i $idxlist {lappend cnamelist [sqlite3_column_name $STMT $i]}
259: set cnamelist
260: } $names
261:
262: # Column names in UTF-16
263: ifcapable {utf16} {
264: do_test $test.2 {
265: set cnamelist [list]
266: foreach i $idxlist {
267: lappend cnamelist [utf8 [sqlite3_column_name16 $STMT $i]]
268: }
269: set cnamelist
270: } $names
271: }
272:
273: # Column names in UTF-8
274: do_test $test.3 {
275: set cnamelist [list]
276: foreach i $idxlist {lappend cnamelist [sqlite3_column_name $STMT $i]}
277: set cnamelist
278: } $names
279:
280: # Column names in UTF-16
281: ifcapable {utf16} {
282: do_test $test.4 {
283: set cnamelist [list]
284: foreach i $idxlist {
285: lappend cnamelist [utf8 [sqlite3_column_name16 $STMT $i]]
286: }
287: set cnamelist
288: } $names
289: }
290:
291: # Column names in UTF-8
292: do_test $test.5 {
293: set cnamelist [list]
294: foreach i $idxlist {lappend cnamelist [sqlite3_column_decltype $STMT $i]}
295: set cnamelist
296: } $decltypes
297:
298: # Column declaration types in UTF-16
299: ifcapable {utf16} {
300: do_test $test.6 {
301: set cnamelist [list]
302: foreach i $idxlist {
303: lappend cnamelist [utf8 [sqlite3_column_decltype16 $STMT $i]]
304: }
305: set cnamelist
306: } $decltypes
307: }
308:
309:
310: # Test some out of range conditions:
311: ifcapable {utf16} {
312: do_test $test.7 {
313: list \
314: [sqlite3_column_name $STMT -1] \
315: [sqlite3_column_name16 $STMT -1] \
316: [sqlite3_column_decltype $STMT -1] \
317: [sqlite3_column_decltype16 $STMT -1] \
318: [sqlite3_column_name $STMT $numcols] \
319: [sqlite3_column_name16 $STMT $numcols] \
320: [sqlite3_column_decltype $STMT $numcols] \
321: [sqlite3_column_decltype16 $STMT $numcols]
322: } {{} {} {} {} {} {} {} {}}
323: }
324: }
325:
326: # This proc is used to test the following API calls:
327: #
328: # sqlite3_column_origin_name
329: # sqlite3_column_origin_name16
330: # sqlite3_column_table_name
331: # sqlite3_column_table_name16
332: # sqlite3_column_database_name
333: # sqlite3_column_database_name16
334: #
335: # $STMT is a compiled SQL statement. $test is a prefix
336: # to use for test names within this proc. $names is a list
337: # of the column names that should be returned by $STMT.
338: # $decltypes is a list of column declaration types for $STMT.
339: #
340: # Example:
341: #
342: # set STMT [sqlite3_prepare "SELECT 1, 2, 2;" -1 DUMMY]
343: # check_header test1.1 {1 2 3} {"" "" ""}
344: #
345: proc check_origin_header {STMT test dbs tables cols} {
346: # If sqlite3_column_origin_name() and friends are not compiled into
347: # this build, this proc is a no-op.
348: ifcapable columnmetadata {
349: # Use the return value of sqlite3_column_count() to build
350: # a list of column indexes. i.e. If sqlite3_column_count
351: # is 3, build the list {0 1 2}.
352: set ::idxlist [list]
353: set ::numcols [sqlite3_column_count $STMT]
354: for {set i 0} {$i < $::numcols} {incr i} {lappend ::idxlist $i}
355:
356: # Database names in UTF-8
357: do_test $test.8 {
358: set cnamelist [list]
359: foreach i $idxlist {
360: lappend cnamelist [sqlite3_column_database_name $STMT $i]
361: }
362: set cnamelist
363: } $dbs
364:
365: # Database names in UTF-16
366: ifcapable {utf16} {
367: do_test $test.9 {
368: set cnamelist [list]
369: foreach i $idxlist {
370: lappend cnamelist [utf8 [sqlite3_column_database_name16 $STMT $i]]
371: }
372: set cnamelist
373: } $dbs
374: }
375:
376: # Table names in UTF-8
377: do_test $test.10 {
378: set cnamelist [list]
379: foreach i $idxlist {
380: lappend cnamelist [sqlite3_column_table_name $STMT $i]
381: }
382: set cnamelist
383: } $tables
384:
385: # Table names in UTF-16
386: ifcapable {utf16} {
387: do_test $test.11 {
388: set cnamelist [list]
389: foreach i $idxlist {
390: lappend cnamelist [utf8 [sqlite3_column_table_name16 $STMT $i]]
391: }
392: set cnamelist
393: } $tables
394: }
395:
396: # Origin names in UTF-8
397: do_test $test.12 {
398: set cnamelist [list]
399: foreach i $idxlist {
400: lappend cnamelist [sqlite3_column_origin_name $STMT $i]
401: }
402: set cnamelist
403: } $cols
404:
405: # Origin declaration types in UTF-16
406: ifcapable {utf16} {
407: do_test $test.13 {
408: set cnamelist [list]
409: foreach i $idxlist {
410: lappend cnamelist [utf8 [sqlite3_column_origin_name16 $STMT $i]]
411: }
412: set cnamelist
413: } $cols
414: }
415: }
416: }
417:
418: # This proc is used to test the following APIs:
419: #
420: # sqlite3_data_count
421: # sqlite3_column_type
422: # sqlite3_column_int
423: # sqlite3_column_text
424: # sqlite3_column_text16
425: # sqlite3_column_double
426: #
427: # $STMT is a compiled SQL statement for which the previous call
428: # to sqlite3_step returned SQLITE_ROW. $test is a prefix to use
429: # for test names within this proc. $types is a list of the
430: # manifest types for the current row. $ints, $doubles and $strings
431: # are lists of the integer, real and string representations of
432: # the values in the current row.
433: #
434: # Example:
435: #
436: # set STMT [sqlite3_prepare "SELECT 'hello', 1.1, NULL" -1 DUMMY]
437: # sqlite3_step $STMT
438: # check_data test1.2 {TEXT REAL NULL} {0 1 0} {0 1.1 0} {hello 1.1 {}}
439: #
440: proc check_data {STMT test types ints doubles strings} {
441:
442: # Use the return value of sqlite3_column_count() to build
443: # a list of column indexes. i.e. If sqlite3_column_count
444: # is 3, build the list {0 1 2}.
445: set ::idxlist [list]
446: set numcols [sqlite3_data_count $STMT]
447: for {set i 0} {$i < $numcols} {incr i} {lappend ::idxlist $i}
448:
449: # types
450: do_test $test.1 {
451: set types [list]
452: foreach i $idxlist {lappend types [sqlite3_column_type $STMT $i]}
453: set types
454: } $types
455:
456: # Integers
457: do_test $test.2 {
458: set ints [list]
459: foreach i $idxlist {lappend ints [sqlite3_column_int64 $STMT $i]}
460: set ints
461: } $ints
462:
463: # bytes
464: set lens [list]
465: foreach i $::idxlist {
466: lappend lens [string length [lindex $strings $i]]
467: }
468: do_test $test.3 {
469: set bytes [list]
470: set lens [list]
471: foreach i $idxlist {
472: lappend bytes [sqlite3_column_bytes $STMT $i]
473: }
474: set bytes
475: } $lens
476:
477: # bytes16
478: ifcapable {utf16} {
479: set lens [list]
480: foreach i $::idxlist {
481: lappend lens [expr 2 * [string length [lindex $strings $i]]]
482: }
483: do_test $test.4 {
484: set bytes [list]
485: set lens [list]
486: foreach i $idxlist {
487: lappend bytes [sqlite3_column_bytes16 $STMT $i]
488: }
489: set bytes
490: } $lens
491: }
492:
493: # Blob
494: do_test $test.5 {
495: set utf8 [list]
496: foreach i $idxlist {lappend utf8 [sqlite3_column_blob $STMT $i]}
497: set utf8
498: } $strings
499:
500: # UTF-8
501: do_test $test.6 {
502: set utf8 [list]
503: foreach i $idxlist {lappend utf8 [sqlite3_column_text $STMT $i]}
504: set utf8
505: } $strings
506:
507: # Floats
508: do_test $test.7 {
509: set utf8 [list]
510: foreach i $idxlist {lappend utf8 [sqlite3_column_double $STMT $i]}
511: set utf8
512: } $doubles
513:
514: # UTF-16
515: ifcapable {utf16} {
516: do_test $test.8 {
517: set utf8 [list]
518: foreach i $idxlist {lappend utf8 [utf8 [sqlite3_column_text16 $STMT $i]]}
519: set utf8
520: } $strings
521: }
522:
523: # Integers
524: do_test $test.9 {
525: set ints [list]
526: foreach i $idxlist {lappend ints [sqlite3_column_int $STMT $i]}
527: set ints
528: } $ints
529:
530: # Floats
531: do_test $test.10 {
532: set utf8 [list]
533: foreach i $idxlist {lappend utf8 [sqlite3_column_double $STMT $i]}
534: set utf8
535: } $doubles
536:
537: # UTF-8
538: do_test $test.11 {
539: set utf8 [list]
540: foreach i $idxlist {lappend utf8 [sqlite3_column_text $STMT $i]}
541: set utf8
542: } $strings
543:
544: # Types
545: do_test $test.12 {
546: set types [list]
547: foreach i $idxlist {lappend types [sqlite3_column_type $STMT $i]}
548: set types
549: } $types
550:
551: # Test that an out of range request returns the equivalent of NULL
552: do_test $test.13 {
553: sqlite3_column_int $STMT -1
554: } {0}
555: do_test $test.13 {
556: sqlite3_column_text $STMT -1
557: } {}
558:
559: }
560:
561: ifcapable !floatingpoint {
562: finish_test
563: return
564: }
565:
566: do_test capi3-5.0 {
567: execsql {
568: CREATE TABLE t1(a VARINT, b BLOB, c VARCHAR(16));
569: INSERT INTO t1 VALUES(1, 2, 3);
570: INSERT INTO t1 VALUES('one', 'two', NULL);
571: INSERT INTO t1 VALUES(1.2, 1.3, 1.4);
572: }
573: set sql "SELECT * FROM t1"
574: set STMT [sqlite3_prepare $DB $sql -1 TAIL]
575: sqlite3_column_count $STMT
576: } 3
577:
578: check_header $STMT capi3-5.1 {a b c} {VARINT BLOB VARCHAR(16)}
579: check_origin_header $STMT capi3-5.1 {main main main} {t1 t1 t1} {a b c}
580: do_test capi3-5.2 {
581: sqlite3_step $STMT
582: } SQLITE_ROW
583:
584: check_header $STMT capi3-5.3 {a b c} {VARINT BLOB VARCHAR(16)}
585: check_origin_header $STMT capi3-5.3 {main main main} {t1 t1 t1} {a b c}
586: check_data $STMT capi3-5.4 {INTEGER INTEGER TEXT} {1 2 3} {1.0 2.0 3.0} {1 2 3}
587:
588: do_test capi3-5.5 {
589: sqlite3_step $STMT
590: } SQLITE_ROW
591:
592: check_header $STMT capi3-5.6 {a b c} {VARINT BLOB VARCHAR(16)}
593: check_origin_header $STMT capi3-5.6 {main main main} {t1 t1 t1} {a b c}
594: check_data $STMT capi3-5.7 {TEXT TEXT NULL} {0 0 0} {0.0 0.0 0.0} {one two {}}
595:
596: do_test capi3-5.8 {
597: sqlite3_step $STMT
598: } SQLITE_ROW
599:
600: check_header $STMT capi3-5.9 {a b c} {VARINT BLOB VARCHAR(16)}
601: check_origin_header $STMT capi3-5.9 {main main main} {t1 t1 t1} {a b c}
602: check_data $STMT capi3-5.10 {FLOAT FLOAT TEXT} {1 1 1} {1.2 1.3 1.4} {1.2 1.3 1.4}
603:
604: do_test capi3-5.11 {
605: sqlite3_step $STMT
606: } SQLITE_DONE
607:
608: do_test capi3-5.12 {
609: sqlite3_finalize $STMT
610: } SQLITE_OK
611:
612: do_test capi3-5.20 {
613: set sql "SELECT a, sum(b), max(c) FROM t1 GROUP BY a"
614: set STMT [sqlite3_prepare $DB $sql -1 TAIL]
615: sqlite3_column_count $STMT
616: } 3
617:
618: check_header $STMT capi3-5.21 {a sum(b) max(c)} {VARINT {} {}}
619: check_origin_header $STMT capi3-5.22 {main {} {}} {t1 {} {}} {a {} {}}
620: do_test capi3-5.23 {
621: sqlite3_finalize $STMT
622: } SQLITE_OK
623:
624: do_test capi3-5.30 {
625: set sql "SELECT a AS x, sum(b) AS y, max(c) AS z FROM t1 AS m GROUP BY x"
626: set STMT [sqlite3_prepare $DB $sql -1 TAIL]
627: sqlite3_column_count $STMT
628: } 3
629:
630: check_header $STMT capi3-5.31 {x y z} {VARINT {} {}}
631: check_origin_header $STMT capi3-5.32 {main {} {}} {t1 {} {}} {a {} {}}
632: do_test capi3-5.33 {
633: sqlite3_finalize $STMT
634: } SQLITE_OK
635:
636:
637: set ::ENC [execsql {pragma encoding}]
638: db close
639:
640: do_test capi3-6.0 {
641: sqlite3 db test.db
642: set DB [sqlite3_connection_pointer db]
643: if {[sqlite3 -has-codec]==0} { sqlite3_key $DB xyzzy }
644: set sql {SELECT a FROM t1 order by rowid}
645: set STMT [sqlite3_prepare $DB $sql -1 TAIL]
646: expr 0
647: } {0}
648: do_test capi3-6.1 {
649: db cache flush
650: sqlite3_close $DB
651: } {SQLITE_BUSY}
652: do_test capi3-6.2 {
653: sqlite3_step $STMT
654: } {SQLITE_ERROR}
655: #check_data $STMT capi3-6.3 {INTEGER} {1} {1.0} {1}
656: do_test capi3-6.3 {
657: sqlite3_finalize $STMT
658: } {SQLITE_SCHEMA}
659: do_test capi3-6.4-misuse {
660: db cache flush
661: sqlite3_close $DB
662: } {SQLITE_OK}
663: db close
664:
665: # This procedure sets the value of the file-format in file 'test.db'
666: # to $newval. Also, the schema cookie is incremented.
667: #
668: proc set_file_format {newval} {
669: hexio_write test.db 44 [hexio_render_int32 $newval]
670: set schemacookie [hexio_get_int [hexio_read test.db 40 4]]
671: incr schemacookie
672: hexio_write test.db 40 [hexio_render_int32 $schemacookie]
673: return {}
674: }
675:
676: # This procedure returns the value of the file-format in file 'test.db'.
677: #
678: proc get_file_format {{fname test.db}} {
679: return [hexio_get_int [hexio_read $fname 44 4]]
680: }
681:
682: if {![sqlite3 -has-codec]} {
683: # Test what happens when the library encounters a newer file format.
684: do_test capi3-7.1 {
685: set_file_format 5
686: } {}
687: do_test capi3-7.2 {
688: catch { sqlite3 db test.db }
689: catchsql {
690: SELECT * FROM sqlite_master;
691: }
692: } {1 {unsupported file format}}
693: db close
694: }
695:
696: if {![sqlite3 -has-codec]} {
697: # Now test that the library correctly handles bogus entries in the
698: # sqlite_master table (schema corruption).
699: do_test capi3-8.1 {
700: forcedelete test.db test.db-journal
701: sqlite3 db test.db
702: execsql {
703: CREATE TABLE t1(a);
704: }
705: db close
706: } {}
707: do_test capi3-8.2 {
708: sqlite3 db test.db
709: execsql {
710: PRAGMA writable_schema=ON;
711: INSERT INTO sqlite_master VALUES(NULL,NULL,NULL,NULL,NULL);
712: }
713: db close
714: } {}
715: do_test capi3-8.3 {
716: catch { sqlite3 db test.db }
717: catchsql {
718: SELECT * FROM sqlite_master;
719: }
720: } {1 {malformed database schema (?)}}
721: do_test capi3-8.4 {
722: # Build a 5-field row record. The first field is a string 'table', and
723: # subsequent fields are all NULL.
724: db close
725: forcedelete test.db test.db-journal
726: sqlite3 db test.db
727: execsql {
728: CREATE TABLE t1(a);
729: PRAGMA writable_schema=ON;
730: INSERT INTO sqlite_master VALUES('table',NULL,NULL,NULL,NULL);
731: }
732: db close
733: } {};
734: do_test capi3-8.5 {
735: catch { sqlite3 db test.db }
736: catchsql {
737: SELECT * FROM sqlite_master;
738: }
739: } {1 {malformed database schema (?)}}
740: db close
741: }
742: forcedelete test.db
743: forcedelete test.db-journal
744:
745:
746: # Test the english language string equivalents for sqlite error codes
747: set code2english [list \
748: SQLITE_OK {not an error} \
749: SQLITE_ERROR {SQL logic error or missing database} \
750: SQLITE_PERM {access permission denied} \
751: SQLITE_ABORT {callback requested query abort} \
752: SQLITE_BUSY {database is locked} \
753: SQLITE_LOCKED {database table is locked} \
754: SQLITE_NOMEM {out of memory} \
755: SQLITE_READONLY {attempt to write a readonly database} \
756: SQLITE_INTERRUPT {interrupted} \
757: SQLITE_IOERR {disk I/O error} \
758: SQLITE_CORRUPT {database disk image is malformed} \
759: SQLITE_FULL {database or disk is full} \
760: SQLITE_CANTOPEN {unable to open database file} \
761: SQLITE_EMPTY {table contains no data} \
762: SQLITE_SCHEMA {database schema has changed} \
763: SQLITE_CONSTRAINT {constraint failed} \
764: SQLITE_MISMATCH {datatype mismatch} \
765: SQLITE_MISUSE {library routine called out of sequence} \
766: SQLITE_NOLFS {large file support is disabled} \
767: SQLITE_AUTH {authorization denied} \
768: SQLITE_FORMAT {auxiliary database format error} \
769: SQLITE_RANGE {bind or column index out of range} \
770: SQLITE_NOTADB {file is encrypted or is not a database} \
771: unknownerror {unknown error} \
772: ]
773:
774: set test_number 1
775: foreach {code english} $code2english {
776: do_test capi3-9.$test_number "sqlite3_test_errstr $code" $english
777: incr test_number
778: }
779:
780: # Test the error message when a "real" out of memory occurs.
781: ifcapable memdebug {
782: do_test capi3-10-1 {
783: sqlite3 db test.db
784: set DB [sqlite3_connection_pointer db]
785: sqlite3_memdebug_fail 1
786: catchsql {
787: select * from sqlite_master;
788: }
789: } {1 {out of memory}}
790: do_test capi3-10-2 {
791: sqlite3_errmsg $::DB
792: } {out of memory}
793: ifcapable {utf16} {
794: do_test capi3-10-3 {
795: utf8 [sqlite3_errmsg16 $::DB]
796: } {out of memory}
797: }
798: db close
799: sqlite3_memdebug_fail -1
800: do_test capi3-10-4 {
801: sqlite3 db test.db
802: set DB [sqlite3_connection_pointer db]
803: sqlite3_memdebug_fail 1
804: catchsql {
805: select * from sqlite_master where rowid>5;
806: }
807: } {1 {out of memory}}
808: do_test capi3-10-5 {
809: sqlite3_errmsg $::DB
810: } {out of memory}
811: ifcapable {utf16} {
812: do_test capi3-10-6 {
813: utf8 [sqlite3_errmsg16 $::DB]
814: } {out of memory}
815: }
816: db close
817: sqlite3_memdebug_fail -1
818: }
819:
820: # The following tests - capi3-11.* - test that a COMMIT or ROLLBACK
821: # statement issued while there are still outstanding VMs that are part of
822: # the transaction fails.
823: sqlite3 db test.db
824: set DB [sqlite3_connection_pointer db]
825: sqlite_register_test_function $DB func
826: do_test capi3-11.1 {
827: execsql {
828: BEGIN;
829: CREATE TABLE t1(a, b);
830: INSERT INTO t1 VALUES(1, 'int');
831: INSERT INTO t1 VALUES(2, 'notatype');
832: }
833: } {}
834: do_test capi3-11.1.1 {
835: sqlite3_get_autocommit $DB
836: } 0
837: do_test capi3-11.2 {
838: set STMT [sqlite3_prepare $DB "SELECT func(b, a) FROM t1" -1 TAIL]
839: sqlite3_step $STMT
840: } {SQLITE_ROW}
841:
842: # As of 3.6.5 a COMMIT is OK during while a query is still running -
843: # as long as it is a read-only query and not an incremental BLOB write.
844: #
845: do_test capi3-11.3.1 {
846: catchsql {
847: COMMIT;
848: }
849: } {0 {}}
850: do_test capi3-11.3.2 {
851: sqlite3_extended_errcode $DB
852: } {SQLITE_OK}
853: do_test capi3-11.3.3 {
854: sqlite3_get_autocommit $DB
855: } 1
856: do_test capi3-11.3.4 {
857: db eval {PRAGMA lock_status}
858: } {main shared temp closed}
859:
860: do_test capi3-11.4 {
861: sqlite3_step $STMT
862: } {SQLITE_ERROR}
863: do_test capi3-11.5 {
864: sqlite3_finalize $STMT
865: } {SQLITE_ERROR}
866: do_test capi3-11.6 {
867: catchsql {
868: SELECT * FROM t1;
869: }
870: } {0 {1 int 2 notatype}}
871: do_test capi3-11.7 {
872: sqlite3_get_autocommit $DB
873: } 1
874: do_test capi3-11.8 {
875: execsql {
876: CREATE TABLE t2(a);
877: INSERT INTO t2 VALUES(1);
878: INSERT INTO t2 VALUES(2);
879: BEGIN;
880: INSERT INTO t2 VALUES(3);
881: }
882: } {}
883: do_test capi3-11.8.1 {
884: sqlite3_get_autocommit $DB
885: } 0
886: do_test capi3-11.9 {
887: set STMT [sqlite3_prepare $DB "SELECT a FROM t2" -1 TAIL]
888: sqlite3_step $STMT
889: } {SQLITE_ROW}
890: do_test capi3-11.9.1 {
891: sqlite3_get_autocommit $DB
892: } 0
893: do_test capi3-11.9.2 {
894: catchsql {
895: ROLLBACK;
896: }
897: } {1 {cannot rollback transaction - SQL statements in progress}}
898: do_test capi3-11.9.3 {
899: sqlite3_get_autocommit $DB
900: } 0
901: do_test capi3-11.10 {
902: sqlite3_step $STMT
903: } {SQLITE_ROW}
904: do_test capi3-11.11 {
905: sqlite3_step $STMT
906: } {SQLITE_ROW}
907: do_test capi3-11.12 {
908: sqlite3_step $STMT
909: } {SQLITE_DONE}
910: do_test capi3-11.13 {
911: sqlite3_finalize $STMT
912: } {SQLITE_OK}
913: do_test capi3-11.14 {
914: execsql {
915: SELECT a FROM t2;
916: }
917: } {1 2 3}
918: do_test capi3-11.14.1 {
919: sqlite3_get_autocommit $DB
920: } 0
921: do_test capi3-11.15 {
922: catchsql {
923: ROLLBACK;
924: }
925: } {0 {}}
926: do_test capi3-11.15.1 {
927: sqlite3_get_autocommit $DB
928: } 1
929: do_test capi3-11.16 {
930: execsql {
931: SELECT a FROM t2;
932: }
933: } {1 2}
934:
935: # Sanity check on the definition of 'outstanding VM'. This means any VM
936: # that has had sqlite3_step() called more recently than sqlite3_finalize() or
937: # sqlite3_reset(). So a VM that has just been prepared or reset does not
938: # count as an active VM.
939: do_test capi3-11.17 {
940: execsql {
941: BEGIN;
942: }
943: } {}
944: do_test capi3-11.18 {
945: set STMT [sqlite3_prepare $DB "SELECT a FROM t1" -1 TAIL]
946: catchsql {
947: COMMIT;
948: }
949: } {0 {}}
950: do_test capi3-11.19 {
951: sqlite3_step $STMT
952: } {SQLITE_ROW}
953: do_test capi3-11.20 {
954: catchsql {
955: BEGIN;
956: COMMIT;
957: }
958: } {0 {}}
959: do_test capi3-11.20 {
960: sqlite3_reset $STMT
961: catchsql {
962: COMMIT;
963: }
964: } {1 {cannot commit - no transaction is active}}
965: do_test capi3-11.21 {
966: sqlite3_finalize $STMT
967: } {SQLITE_OK}
968:
969: # The following tests - capi3-12.* - check that its Ok to start a
970: # transaction while other VMs are active, and that its Ok to execute
971: # atomic updates in the same situation
972: #
973: do_test capi3-12.1 {
974: set STMT [sqlite3_prepare $DB "SELECT a FROM t2" -1 TAIL]
975: sqlite3_step $STMT
976: } {SQLITE_ROW}
977: do_test capi3-12.2 {
978: catchsql {
979: INSERT INTO t1 VALUES(3, NULL);
980: }
981: } {0 {}}
982: do_test capi3-12.3 {
983: catchsql {
984: INSERT INTO t2 VALUES(4);
985: }
986: } {0 {}}
987: do_test capi3-12.4 {
988: catchsql {
989: BEGIN;
990: INSERT INTO t1 VALUES(4, NULL);
991: }
992: } {0 {}}
993: do_test capi3-12.5 {
994: sqlite3_step $STMT
995: } {SQLITE_ROW}
996: do_test capi3-12.5.1 {
997: sqlite3_step $STMT
998: } {SQLITE_ROW}
999: do_test capi3-12.6 {
1000: sqlite3_step $STMT
1001: } {SQLITE_DONE}
1002: do_test capi3-12.7 {
1003: sqlite3_finalize $STMT
1004: } {SQLITE_OK}
1005: do_test capi3-12.8 {
1006: execsql {
1007: COMMIT;
1008: SELECT a FROM t1;
1009: }
1010: } {1 2 3 4}
1011:
1012: # Test cases capi3-13.* test the sqlite3_clear_bindings() and
1013: # sqlite3_sleep APIs.
1014: #
1015: if {[llength [info commands sqlite3_clear_bindings]]>0} {
1016: do_test capi3-13.1 {
1017: execsql {
1018: DELETE FROM t1;
1019: }
1020: set STMT [sqlite3_prepare $DB "INSERT INTO t1 VALUES(?, ?)" -1 TAIL]
1021: sqlite3_step $STMT
1022: } {SQLITE_DONE}
1023: do_test capi3-13.2 {
1024: sqlite3_reset $STMT
1025: sqlite3_bind_text $STMT 1 hello 5
1026: sqlite3_bind_text $STMT 2 world 5
1027: sqlite3_step $STMT
1028: } {SQLITE_DONE}
1029: do_test capi3-13.3 {
1030: sqlite3_reset $STMT
1031: sqlite3_clear_bindings $STMT
1032: sqlite3_step $STMT
1033: } {SQLITE_DONE}
1034: do_test capi3-13-4 {
1035: sqlite3_finalize $STMT
1036: execsql {
1037: SELECT * FROM t1;
1038: }
1039: } {{} {} hello world {} {}}
1040: }
1041: if {[llength [info commands sqlite3_sleep]]>0} {
1042: do_test capi3-13-5 {
1043: set ms [sqlite3_sleep 80]
1044: expr {$ms==80 || $ms==1000}
1045: } {1}
1046: }
1047:
1048: # Ticket #1219: Make sure binding APIs can handle a NULL pointer.
1049: #
1050: do_test capi3-14.1-misuse {
1051: set rc [catch {sqlite3_bind_text 0 1 hello 5} msg]
1052: lappend rc $msg
1053: } {1 SQLITE_MISUSE}
1054:
1055: # Ticket #1650: Honor the nBytes parameter to sqlite3_prepare.
1056: #
1057: do_test capi3-15.1 {
1058: set sql {SELECT * FROM t2}
1059: set nbytes [string length $sql]
1060: append sql { WHERE a==1}
1061: set STMT [sqlite3_prepare $DB $sql $nbytes TAIL]
1062: sqlite3_step $STMT
1063: sqlite3_column_int $STMT 0
1064: } {1}
1065: do_test capi3-15.2 {
1066: sqlite3_step $STMT
1067: sqlite3_column_int $STMT 0
1068: } {2}
1069: do_test capi3-15.3 {
1070: sqlite3_finalize $STMT
1071: } {SQLITE_OK}
1072: do_test capi3-15.4 {
1073: # 123456789 1234567
1074: set sql {SELECT 1234567890}
1075: set STMT [sqlite3_prepare $DB $sql 8 TAIL]
1076: sqlite3_step $STMT
1077: set v1 [sqlite3_column_int $STMT 0]
1078: sqlite3_finalize $STMT
1079: set v1
1080: } {1}
1081: do_test capi3-15.5 {
1082: # 123456789 1234567
1083: set sql {SELECT 1234567890}
1084: set STMT [sqlite3_prepare $DB $sql 9 TAIL]
1085: sqlite3_step $STMT
1086: set v1 [sqlite3_column_int $STMT 0]
1087: sqlite3_finalize $STMT
1088: set v1
1089: } {12}
1090: do_test capi3-15.6 {
1091: # 123456789 1234567
1092: set sql {SELECT 1234567890}
1093: set STMT [sqlite3_prepare $DB $sql 12 TAIL]
1094: sqlite3_step $STMT
1095: set v1 [sqlite3_column_int $STMT 0]
1096: sqlite3_finalize $STMT
1097: set v1
1098: } {12345}
1099: do_test capi3-15.7 {
1100: # 123456789 1234567
1101: set sql {SELECT 12.34567890}
1102: set STMT [sqlite3_prepare $DB $sql 12 TAIL]
1103: sqlite3_step $STMT
1104: set v1 [sqlite3_column_double $STMT 0]
1105: sqlite3_finalize $STMT
1106: set v1
1107: } {12.34}
1108: do_test capi3-15.8 {
1109: # 123456789 1234567
1110: set sql {SELECT 12.34567890}
1111: set STMT [sqlite3_prepare $DB $sql 14 TAIL]
1112: sqlite3_step $STMT
1113: set v1 [sqlite3_column_double $STMT 0]
1114: sqlite3_finalize $STMT
1115: set v1
1116: } {12.3456}
1117:
1118: # Make sure code is always generated even if an IF EXISTS or
1119: # IF NOT EXISTS clause is present that the table does not or
1120: # does exists. That way we will always have a prepared statement
1121: # to expire when the schema changes.
1122: #
1123: do_test capi3-16.1 {
1124: set sql {DROP TABLE IF EXISTS t3}
1125: set STMT [sqlite3_prepare $DB $sql -1 TAIL]
1126: sqlite3_finalize $STMT
1127: expr {$STMT!=""}
1128: } {1}
1129: do_test capi3-16.2 {
1130: set sql {CREATE TABLE IF NOT EXISTS t1(x,y)}
1131: set STMT [sqlite3_prepare $DB $sql -1 TAIL]
1132: sqlite3_finalize $STMT
1133: expr {$STMT!=""}
1134: } {1}
1135:
1136: # But still we do not generate code if there is no SQL
1137: #
1138: do_test capi3-16.3 {
1139: set STMT [sqlite3_prepare $DB {} -1 TAIL]
1140: sqlite3_finalize $STMT
1141: expr {$STMT==""}
1142: } {1}
1143: do_test capi3-16.4 {
1144: set STMT [sqlite3_prepare $DB {;} -1 TAIL]
1145: sqlite3_finalize $STMT
1146: expr {$STMT==""}
1147: } {1}
1148:
1149: # Ticket #2426: Misuse of sqlite3_column_* by calling it after
1150: # a sqlite3_reset should be harmless.
1151: #
1152: do_test capi3-17.1 {
1153: set STMT [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
1154: sqlite3_step $STMT
1155: sqlite3_column_int $STMT 0
1156: } {1}
1157: do_test capi3-17.2 {
1158: sqlite3_reset $STMT
1159: sqlite3_column_int $STMT 0
1160: } {0}
1161: do_test capi3-17.3 {
1162: sqlite3_finalize $STMT
1163: } {SQLITE_OK}
1164:
1165: # Verify that sqlite3_step() fails with an SQLITE_SCHEMA error
1166: # when the statement is prepared with sqlite3_prepare() (not
1167: # sqlite3_prepare_v2()) and the schema has changed.
1168: #
1169: do_test capi3-18.1 {
1170: set STMT [sqlite3_prepare db {SELECT * FROM t2} -1 TAIL]
1171: sqlite3 db2 test.db
1172: db2 eval {CREATE TABLE t3(x)}
1173: db2 close
1174: sqlite3_step $STMT
1175: } {SQLITE_ERROR}
1176: do_test capi3-18.2 {
1177: sqlite3_reset $STMT
1178: sqlite3_errcode db
1179: } {SQLITE_SCHEMA}
1180: do_test capi3-18.3 {
1181: sqlite3_errmsg db
1182: } {database schema has changed}
1183: # The error persist on retry when sqlite3_prepare() has been used.
1184: do_test capi3-18.4 {
1185: sqlite3_step $STMT
1186: } {SQLITE_ERROR}
1187: do_test capi3-18.5 {
1188: sqlite3_reset $STMT
1189: sqlite3_errcode db
1190: } {SQLITE_SCHEMA}
1191: do_test capi3-18.6 {
1192: sqlite3_errmsg db
1193: } {database schema has changed}
1194: sqlite3_finalize $STMT
1195:
1196: # Ticket #3134. Prepare a statement with an nBytes parameter of 0.
1197: # Make sure this works correctly and does not reference memory out of
1198: # range.
1199: #
1200: do_test capi3-19.1 {
1201: sqlite3_prepare_tkt3134 db
1202: } {}
1203:
1204: # Tests of the interface when no VFS is registered.
1205: #
1206: if {![info exists tester_do_binarylog]} {
1207: db close
1208: vfs_unregister_all
1209: do_test capi3-20.1 {
1210: sqlite3_sleep 100
1211: } {0}
1212: vfs_reregister_all
1213: }
1214:
1215: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to capi3.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