wasCSharpSQLite – Blame information for rev 7
?pathlinks?
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 |