wasCSharpSQLite – Blame information for rev

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