wasCSharpSQLite – Blame information for rev 7
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
1 | office | 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.70 2009/01/09 02:49:32 drh 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 | file delete -force 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 | file delete -force 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 | file delete -force test.db |
||
743 | file delete -force 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 |