Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / test / capi2.test
blob39f50dd0795be5e1f32597736a1bd86573cb2093
1 # 2003 January 29
3 # The author disclaims copyright to this source code.  In place of
4 # a legal notice, here is a blessing:
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.
10 #***********************************************************************
11 # This file implements regression tests for SQLite library.  The
12 # focus of this script testing the callback-free C/C++ API.
14 # $Id: capi2.test,v 1.37 2008/12/30 17:55:00 drh Exp $
17 set testdir [file dirname $argv0]
18 source $testdir/tester.tcl
20 # Return the text values from the current row pointed at by STMT as a list.
21 proc get_row_values {STMT} {
22   set VALUES [list]
23   for {set i 0} {$i < [sqlite3_data_count $STMT]} {incr i} {
24     lappend VALUES [sqlite3_column_text $STMT $i]
25   }
26   return $VALUES
29 # Return the column names followed by declaration types for the result set
30 # of the SQL statement STMT.
32 # i.e. for:
33 # CREATE TABLE abc(a text, b integer); 
34 # SELECT * FROM abc;
36 # The result is {a b text integer}
37 proc get_column_names {STMT} {
38   set VALUES [list]
39   for {set i 0} {$i < [sqlite3_column_count $STMT]} {incr i} {
40     lappend VALUES [sqlite3_column_name $STMT $i]
41   }
42   for {set i 0} {$i < [sqlite3_column_count $STMT]} {incr i} {
43     lappend VALUES [sqlite3_column_decltype $STMT $i]
44   }
45   return $VALUES
48 # Check basic functionality
50 do_test capi2-1.1 {
51   set DB [sqlite3_connection_pointer db]
52   execsql {CREATE TABLE t1(a,b,c)}
53   set VM [sqlite3_prepare $DB {SELECT name, rowid FROM sqlite_master} -1 TAIL]
54   set TAIL
55 } {}
56 do_test capi2-1.2 {
57   sqlite3_step $VM
58 } {SQLITE_ROW}
59 do_test capi2-1.3 {
60   sqlite3_data_count $VM
61 } {2}
62 do_test capi2-1.4 {
63   get_row_values $VM
64 } {t1 1}
65 do_test capi2-1.5 {
66   get_column_names $VM
67 } {name rowid text INTEGER}
68 do_test capi2-1.6 {
69   sqlite3_step $VM 
70 } {SQLITE_DONE}
71 do_test capi2-1.7 {
72   list [sqlite3_column_count $VM] [get_row_values $VM] [get_column_names $VM]
73 } {2 {} {name rowid text INTEGER}}
75 # This used to be SQLITE_MISUSE.  But now we automatically reset prepared
76 # statements.
77 ifcapable autoreset {
78   do_test capi2-1.8 {
79     sqlite3_step $VM
80   } {SQLITE_ROW}
81 } else {
82   do_test capi2-1.8 {
83     sqlite3_step $VM
84   } {SQLITE_MISUSE}
87 # Update: In v2, once SQLITE_MISUSE is returned the statement handle cannot
88 # be interrogated for more information. However in v3, since the column
89 # count, names and types are determined at compile time, these are still
90 # accessible after an SQLITE_MISUSE error.
91 do_test capi2-1.9 {
92   sqlite3_reset $VM
93   list [sqlite3_column_count $VM] [get_row_values $VM] [get_column_names $VM]
94 } {2 {} {name rowid text INTEGER}}
95 do_test capi2-1.10 {
96   sqlite3_data_count $VM
97 } {0}
99 do_test capi2-1.11 {
100   sqlite3_finalize $VM
101 } {SQLITE_OK}
103 # Check to make sure that the "tail" of a multi-statement SQL script
104 # is returned by sqlite3_prepare.
106 do_test capi2-2.1 {
107   set SQL {
108     SELECT name, rowid FROM sqlite_master;
109     SELECT name, rowid FROM sqlite_master WHERE 0;
110     -- A comment at the end
111   }
112   set VM [sqlite3_prepare $DB $SQL -1 SQL]
113   set SQL
114 } {
115     SELECT name, rowid FROM sqlite_master WHERE 0;
116     -- A comment at the end
117   }
118 do_test capi2-2.2 {
119   set r [sqlite3_step $VM]
120   lappend r [sqlite3_column_count $VM] \
121             [get_row_values $VM] \
122             [get_column_names $VM]
123 } {SQLITE_ROW 2 {t1 1} {name rowid text INTEGER}}
124 do_test capi2-2.3 {
125   set r [sqlite3_step $VM]
126   lappend r [sqlite3_column_count $VM] \
127             [get_row_values $VM] \
128             [get_column_names $VM]
129 } {SQLITE_DONE 2 {} {name rowid text INTEGER}}
130 do_test capi2-2.4 {
131   sqlite3_finalize $VM
132 } {SQLITE_OK}
133 do_test capi2-2.5 {
134   set VM [sqlite3_prepare $DB $SQL -1 SQL]
135   set SQL
136 } {
137     -- A comment at the end
138   }
139 do_test capi2-2.6 {
140   set r [sqlite3_step $VM]
141   lappend r [sqlite3_column_count $VM] \
142             [get_row_values $VM] \
143             [get_column_names $VM]
144 } {SQLITE_DONE 2 {} {name rowid text INTEGER}}
145 do_test capi2-2.7 {
146   sqlite3_finalize $VM
147 } {SQLITE_OK}
148 do_test capi2-2.8 {
149   set VM [sqlite3_prepare $DB $SQL -1 SQL]
150   list $SQL $VM
151 } {{} {}}
153 # Check the error handling.
155 do_test capi2-3.1 {
156   set rc [catch {
157       sqlite3_prepare $DB {select bogus from sqlite_master} -1 TAIL
158   } msg]
159   lappend rc $msg $TAIL
160 } {1 {(1) no such column: bogus} {}}
161 do_test capi2-3.2 {
162   set rc [catch {
163       sqlite3_prepare $DB {select bogus from } -1 TAIL
164   } msg]
165   lappend rc $msg $TAIL
166 } {1 {(1) near " ": syntax error} {}}
167 do_test capi2-3.3 {
168   set rc [catch {
169       sqlite3_prepare $DB {;;;;select bogus from sqlite_master} -1 TAIL
170   } msg]
171   lappend rc $msg $TAIL
172 } {1 {(1) no such column: bogus} {}}
173 do_test capi2-3.4 {
174   set rc [catch {
175       sqlite3_prepare $DB {select bogus from sqlite_master;x;} -1 TAIL
176   } msg]
177   lappend rc $msg $TAIL
178 } {1 {(1) no such column: bogus} {x;}}
179 do_test capi2-3.5 {
180   set rc [catch {
181       sqlite3_prepare $DB {select bogus from sqlite_master;;;x;} -1 TAIL
182   } msg]
183   lappend rc $msg $TAIL
184 } {1 {(1) no such column: bogus} {;;x;}}
185 do_test capi2-3.6 {
186   set rc [catch {
187       sqlite3_prepare $DB {select 5/0} -1 TAIL
188   } VM]
189   lappend rc $TAIL
190 } {0 {}}
191 do_test capi2-3.7 {
192   list [sqlite3_step $VM] \
193        [sqlite3_column_count $VM] \
194        [get_row_values $VM] \
195        [get_column_names $VM]
196 } {SQLITE_ROW 1 {{}} {5/0 {}}}
197 do_test capi2-3.8 {
198   sqlite3_finalize $VM
199 } {SQLITE_OK}
200 do_test capi2-3.9 {
201   execsql {CREATE UNIQUE INDEX i1 ON t1(a)}
202   set VM [sqlite3_prepare $DB {INSERT INTO t1 VALUES(1,2,3)} -1 TAIL]
203   set TAIL
204 } {}
205 do_test capi2-3.9b {db changes} {0}
206 do_test capi2-3.10 {
207   list [sqlite3_step $VM] \
208        [sqlite3_column_count $VM] \
209        [get_row_values $VM] \
210        [get_column_names $VM]
211 } {SQLITE_DONE 0 {} {}}
213 # Update for v3 - the change has not actually happened until the query is
214 # finalized. Is this going to cause trouble for anyone? Lee Nelson maybe?
215 # (Later:) The change now happens just before SQLITE_DONE is returned.
216 do_test capi2-3.10b {db changes} {1}
217 do_test capi2-3.11 {
218   sqlite3_finalize $VM
219 } {SQLITE_OK}
220 do_test capi2-3.11b {db changes} {1}
221 #do_test capi2-3.12-misuse {
222 #  sqlite3_finalize $VM
223 #} {SQLITE_MISUSE}
224 do_test capi2-3.13 {
225   set VM [sqlite3_prepare $DB {INSERT INTO t1 VALUES(1,3,4)} -1 TAIL]
226   list [sqlite3_step $VM] \
227        [sqlite3_column_count $VM] \
228        [get_row_values $VM] \
229        [get_column_names $VM]
230 } {SQLITE_ERROR 0 {} {}}
232 # Update for v3: Preparing a statement does not affect the change counter.
233 # (Test result changes from 0 to 1).  (Later:) change counter updates occur
234 # when sqlite3_step returns, not at finalize time.
235 do_test capi2-3.13b {db changes} {0}
237 do_test capi2-3.14 {
238   list [sqlite3_finalize $VM] [sqlite3_errmsg $DB] \
239        [sqlite3_extended_errcode $DB]
240 } {SQLITE_CONSTRAINT {UNIQUE constraint failed: t1.a} SQLITE_CONSTRAINT_UNIQUE}
241 do_test capi2-3.15 {
242   set VM [sqlite3_prepare $DB {CREATE TABLE t2(a NOT NULL, b)} -1 TAIL]
243   set TAIL
244 } {}
245 do_test capi2-3.16 {
246   list [sqlite3_step $VM] \
247        [sqlite3_column_count $VM] \
248        [get_row_values $VM] \
249        [get_column_names $VM]
250 } {SQLITE_DONE 0 {} {}}
251 do_test capi2-3.17 {
252   list [sqlite3_finalize $VM] [sqlite3_errmsg $DB]
253 } {SQLITE_OK {not an error}}
254 do_test capi2-3.18 {
255   set VM [sqlite3_prepare $DB {INSERT INTO t2 VALUES(NULL,2)} -1 TAIL]
256   list [sqlite3_step $VM] \
257        [sqlite3_column_count $VM] \
258        [get_row_values $VM] \
259        [get_column_names $VM]
260 } {SQLITE_ERROR 0 {} {}}
261 do_test capi2-3.19 {
262   list [sqlite3_finalize $VM] [sqlite3_errmsg $DB] \
263        [sqlite3_extended_errcode $DB]
264 } {SQLITE_CONSTRAINT {NOT NULL constraint failed: t2.a} SQLITE_CONSTRAINT_NOTNULL}
266 do_test capi2-3.20 {
267   execsql {
268     CREATE TABLE a1(message_id, name , UNIQUE(message_id, name) );
269     INSERT INTO a1 VALUES(1, 1);
270   }
271 } {}
272 do_test capi2-3.21 {
273   set VM [sqlite3_prepare $DB {INSERT INTO a1 VALUES(1, 1)} -1 TAIL]
274   sqlite3_step $VM
275 } {SQLITE_ERROR}
276 do_test capi2-3.22 {
277   sqlite3_errcode $DB
278 } {SQLITE_ERROR}
279 do_test capi2-3.23 {
280   sqlite3_finalize $VM
281 } {SQLITE_CONSTRAINT}
282 do_test capi2-3.24 {
283   list [sqlite3_errcode $DB] [sqlite3_extended_errcode $DB]
284 } {SQLITE_CONSTRAINT SQLITE_CONSTRAINT_UNIQUE}
286 # Two or more virtual machines exists at the same time.
288 do_test capi2-4.1 {
289   set VM1 [sqlite3_prepare $DB {INSERT INTO t2 VALUES(1,2)} -1 TAIL]
290   set TAIL
291 } {}
292 do_test capi2-4.2 {
293   set VM2 [sqlite3_prepare $DB {INSERT INTO t2 VALUES(2,3)} -1 TAIL]
294   set TAIL
295 } {}
296 do_test capi2-4.3 {
297   set VM3 [sqlite3_prepare $DB {INSERT INTO t2 VALUES(3,4)} -1 TAIL]
298   set TAIL
299 } {}
300 do_test capi2-4.4 {
301   list [sqlite3_step $VM2] \
302        [sqlite3_column_count $VM2] \
303        [get_row_values $VM2] \
304        [get_column_names $VM2]
305 } {SQLITE_DONE 0 {} {}}
306 do_test capi2-4.5 {
307   execsql {SELECT * FROM t2 ORDER BY a}
308 } {2 3}
309 do_test capi2-4.6 {
310   sqlite3_finalize $VM2
311 } {SQLITE_OK}
312 do_test capi2-4.7 {
313   list [sqlite3_step $VM3] \
314        [sqlite3_column_count $VM3] \
315        [get_row_values $VM3] \
316        [get_column_names $VM3]
317 } {SQLITE_DONE 0 {} {}}
318 do_test capi2-4.8 {
319   execsql {SELECT * FROM t2 ORDER BY a}
320 } {2 3 3 4}
321 do_test capi2-4.9 {
322   sqlite3_finalize $VM3
323 } {SQLITE_OK}
324 do_test capi2-4.10 {
325   list [sqlite3_step $VM1] \
326        [sqlite3_column_count $VM1] \
327        [get_row_values $VM1] \
328        [get_column_names $VM1]
329 } {SQLITE_DONE 0 {} {}}
330 do_test capi2-4.11 {
331   execsql {SELECT * FROM t2 ORDER BY a}
332 } {1 2 2 3 3 4}
333 do_test capi2-4.12 {
334   sqlite3_finalize $VM1
335 } {SQLITE_OK}
337 # Interleaved SELECTs
339 do_test capi2-5.1 {
340   set VM1 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
341   set VM2 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
342   set VM3 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
343   list [sqlite3_step $VM1] \
344        [sqlite3_column_count $VM1] \
345        [get_row_values $VM1] \
346        [get_column_names $VM1]
347 } {SQLITE_ROW 2 {2 3} {a b {} {}}}
348 do_test capi2-5.2 {
349   list [sqlite3_step $VM2] \
350        [sqlite3_column_count $VM2] \
351        [get_row_values $VM2] \
352        [get_column_names $VM2]
353 } {SQLITE_ROW 2 {2 3} {a b {} {}}}
354 do_test capi2-5.3 {
355   list [sqlite3_step $VM1] \
356        [sqlite3_column_count $VM1] \
357        [get_row_values $VM1] \
358        [get_column_names $VM1]
359 } {SQLITE_ROW 2 {3 4} {a b {} {}}}
360 do_test capi2-5.4 {
361   list [sqlite3_step $VM3] \
362        [sqlite3_column_count $VM3] \
363        [get_row_values $VM3] \
364        [get_column_names $VM3]
365 } {SQLITE_ROW 2 {2 3} {a b {} {}}}
366 do_test capi2-5.5 {
367   list [sqlite3_step $VM3] \
368        [sqlite3_column_count $VM3] \
369        [get_row_values $VM3] \
370        [get_column_names $VM3]
371 } {SQLITE_ROW 2 {3 4} {a b {} {}}}
372 do_test capi2-5.6 {
373   list [sqlite3_step $VM3] \
374        [sqlite3_column_count $VM3] \
375        [get_row_values $VM3] \
376        [get_column_names $VM3]
377 } {SQLITE_ROW 2 {1 2} {a b {} {}}}
378 do_test capi2-5.7 {
379   list [sqlite3_step $VM3] \
380        [sqlite3_column_count $VM3] \
381        [get_row_values $VM3] \
382        [get_column_names $VM3]
383 } {SQLITE_DONE 2 {} {a b {} {}}}
384 do_test capi2-5.8 {
385   sqlite3_finalize $VM3
386 } {SQLITE_OK}
387 do_test capi2-5.9 {
388   list [sqlite3_step $VM1] \
389        [sqlite3_column_count $VM1] \
390        [get_row_values $VM1] \
391        [get_column_names $VM1]
392 } {SQLITE_ROW 2 {1 2} {a b {} {}}}
393 do_test capi2-5.10 {
394   sqlite3_finalize $VM1
395 } {SQLITE_OK}
396 do_test capi2-5.11 {
397   list [sqlite3_step $VM2] \
398        [sqlite3_column_count $VM2] \
399        [get_row_values $VM2] \
400        [get_column_names $VM2]
401 } {SQLITE_ROW 2 {3 4} {a b {} {}}}
402 do_test capi2-5.12 {
403   list [sqlite3_step $VM2] \
404        [sqlite3_column_count $VM2] \
405        [get_row_values $VM2] \
406        [get_column_names $VM2]
407 } {SQLITE_ROW 2 {1 2} {a b {} {}}}
408 do_test capi2-5.11 {
409   sqlite3_finalize $VM2
410 } {SQLITE_OK}
412 # Check for proper SQLITE_BUSY returns.
414 do_test capi2-6.1 {
415   execsql {
416     BEGIN;
417     CREATE TABLE t3(x counter);
418     INSERT INTO t3 VALUES(1);
419     INSERT INTO t3 VALUES(2);
420     INSERT INTO t3 SELECT x+2 FROM t3;
421     INSERT INTO t3 SELECT x+4 FROM t3;
422     INSERT INTO t3 SELECT x+8 FROM t3;
423     COMMIT;
424   }
425   set VM1 [sqlite3_prepare $DB {SELECT * FROM t3} -1 TAIL]
426   sqlite3 db2 test.db
427   execsql {BEGIN} db2
428 } {}
429 # Update for v3: BEGIN doesn't write-lock the database. It is quite
430 # difficult to get v3 to write-lock the database, which causes a few
431 # problems for test scripts.
433 # do_test capi2-6.2 {
434 #   list [sqlite3_step $VM1] \
435 #        [sqlite3_column_count $VM1] \
436 #        [get_row_values $VM1] \
437 #        [get_column_names $VM1]
438 # } {SQLITE_BUSY 0 {} {}}
439 do_test capi2-6.3 {
440   execsql {COMMIT} db2
441 } {}
442 do_test capi2-6.4 {
443   list [sqlite3_step $VM1] \
444        [sqlite3_column_count $VM1] \
445        [get_row_values $VM1] \
446        [get_column_names $VM1]
447 } {SQLITE_ROW 1 1 {x counter}}
448 do_test capi2-6.5 {
449   catchsql {INSERT INTO t3 VALUES(10);} db2
450 } {1 {database is locked}}
451 do_test capi2-6.6 {
452   list [sqlite3_step $VM1] \
453        [sqlite3_column_count $VM1] \
454        [get_row_values $VM1] \
455        [get_column_names $VM1]
456 } {SQLITE_ROW 1 2 {x counter}}
457 do_test capi2-6.7 {
458   execsql {SELECT * FROM t2} db2
459 } {2 3 3 4 1 2}
460 do_test capi2-6.8 {
461   list [sqlite3_step $VM1] \
462        [sqlite3_column_count $VM1] \
463        [get_row_values $VM1] \
464        [get_column_names $VM1]
465 } {SQLITE_ROW 1 3 {x counter}}
466 do_test capi2-6.9 {
467   execsql {SELECT * FROM t2} 
468 } {2 3 3 4 1 2}
469 do_test capi2-6.10 {
470   list [sqlite3_step $VM1] \
471        [sqlite3_column_count $VM1] \
472        [get_row_values $VM1] \
473        [get_column_names $VM1]
474 } {SQLITE_ROW 1 4 {x counter}}
475 do_test capi2-6.11 {
476   execsql {BEGIN}
477 } {}
478 do_test capi2-6.12 {
479   list [sqlite3_step $VM1] \
480        [sqlite3_column_count $VM1] \
481        [get_row_values $VM1] \
482        [get_column_names $VM1]
483 } {SQLITE_ROW 1 5 {x counter}}
485 # A read no longer blocks a write in the same connection.
486 #do_test capi2-6.13 {
487 #  catchsql {UPDATE t3 SET x=x+1}
488 #} {1 {database table is locked}}
490 do_test capi2-6.14 {
491   list [sqlite3_step $VM1] \
492        [sqlite3_column_count $VM1] \
493        [get_row_values $VM1] \
494        [get_column_names $VM1]
495 } {SQLITE_ROW 1 6 {x counter}}
496 do_test capi2-6.15 {
497   execsql {SELECT * FROM t1}
498 } {1 2 3}
499 do_test capi2-6.16 {
500   list [sqlite3_step $VM1] \
501        [sqlite3_column_count $VM1] \
502        [get_row_values $VM1] \
503        [get_column_names $VM1]
504 } {SQLITE_ROW 1 7 {x counter}}
505 do_test capi2-6.17 {
506   catchsql {UPDATE t1 SET b=b+1}
507 } {0 {}}
508 do_test capi2-6.18 {
509   list [sqlite3_step $VM1] \
510        [sqlite3_column_count $VM1] \
511        [get_row_values $VM1] \
512        [get_column_names $VM1]
513 } {SQLITE_ROW 1 8 {x counter}}
514 do_test capi2-6.19 {
515   execsql {SELECT * FROM t1}
516 } {1 3 3}
517 do_test capi2-6.20 {
518   list [sqlite3_step $VM1] \
519        [sqlite3_column_count $VM1] \
520        [get_row_values $VM1] \
521        [get_column_names $VM1]
522 } {SQLITE_ROW 1 9 {x counter}}
523 #do_test capi2-6.21 {
524 #  execsql {ROLLBACK; SELECT * FROM t1}
525 #} {1 2 3}
526 do_test capi2-6.22 {
527   list [sqlite3_step $VM1] \
528        [sqlite3_column_count $VM1] \
529        [get_row_values $VM1] \
530        [get_column_names $VM1]
531 } {SQLITE_ROW 1 10 {x counter}}
532 #do_test capi2-6.23 {
533 #  execsql {BEGIN TRANSACTION;}
534 #} {}
535 do_test capi2-6.24 {
536   list [sqlite3_step $VM1] \
537        [sqlite3_column_count $VM1] \
538        [get_row_values $VM1] \
539        [get_column_names $VM1]
540 } {SQLITE_ROW 1 11 {x counter}}
541 do_test capi2-6.25 {
542   execsql {
543     INSERT INTO t1 VALUES(2,3,4);
544     SELECT * FROM t1;
545   }
546 } {1 3 3 2 3 4}
547 do_test capi2-6.26 {
548   list [sqlite3_step $VM1] \
549        [sqlite3_column_count $VM1] \
550        [get_row_values $VM1] \
551        [get_column_names $VM1]
552 } {SQLITE_ROW 1 12 {x counter}}
553 do_test capi2-6.27 {
554   catchsql {
555     INSERT INTO t1 VALUES(2,4,5);
556     SELECT * FROM t1;
557   }
558 } {1 {UNIQUE constraint failed: t1.a}}
559 do_test capi2-6.28 {
560   list [sqlite3_step $VM1] \
561        [sqlite3_column_count $VM1] \
562        [get_row_values $VM1] \
563        [get_column_names $VM1]
564 } {SQLITE_ROW 1 13 {x counter}}
565 do_test capi2-6.99 {
566   sqlite3_finalize $VM1
567 } {SQLITE_OK}
568 catchsql {ROLLBACK}
570 do_test capi2-7.1 {
571   stepsql $DB {
572     SELECT * FROM t1
573   }
574 } {0 1 2 3}
575 do_test capi2-7.2 {
576   stepsql $DB {
577     PRAGMA count_changes=on
578   }
579 } {0}
580 do_test capi2-7.3 {
581   stepsql $DB {
582     UPDATE t1 SET a=a+10;
583   }
584 } {0 1}
585 do_test capi2-7.4 {
586   stepsql $DB {
587     INSERT INTO t1 SELECT a+1,b+1,c+1 FROM t1;
588   }
589 } {0 1}
590 do_test capi2-7.4b {sqlite3_changes $DB} {1}
591 do_test capi2-7.5 {
592   stepsql $DB {
593     UPDATE t1 SET a=a+10;
594   }
595 } {0 2}
596 do_test capi2-7.5b {sqlite3_changes $DB} {2}
597 do_test capi2-7.6 {
598   stepsql $DB {
599     SELECT * FROM t1;
600   }
601 } {0 21 2 3 22 3 4}
602 do_test capi2-7.7 {
603   stepsql $DB {
604     INSERT INTO t1 SELECT a+2,b+2,c+2 FROM t1;
605   }
606 } {0 2}
607 do_test capi2-7.8 {
608   sqlite3_changes $DB
609 } {2}
610 do_test capi2-7.9 {
611   stepsql $DB {
612     SELECT * FROM t1;
613   }
614 } {0 21 2 3 22 3 4 23 4 5 24 5 6}
615 do_test capi2-7.10 {
616   stepsql $DB {
617     UPDATE t1 SET a=a-20;
618     SELECT * FROM t1;
619   }
620 } {0 4 1 2 3 2 3 4 3 4 5 4 5 6}
622 # Update for version 3: A SELECT statement no longer resets the change
623 # counter (Test result changes from 0 to 4).
624 do_test capi2-7.11 {
625   sqlite3_changes $DB
626 } {4}
627 do_test capi2-7.11a {
628   execsql {SELECT count(*) FROM t1}
629 } {4}
631 ifcapable {explain} {
632   do_test capi2-7.12 {
633     set x [stepsql $DB {EXPLAIN SELECT * FROM t1}]
634     lindex $x 0
635   } {0}
638 # Ticket #261 - make sure we can finalize before the end of a query.
640 do_test capi2-8.1 {
641   set VM1 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
642   sqlite3_finalize $VM1
643 } {SQLITE_OK}
644   
645 # Tickets #384 and #385 - make sure the TAIL argument to sqlite3_prepare
646 # and all of the return pointers in sqlite_step can be null.
648 do_test capi2-9.1 {
649   set VM1 [sqlite3_prepare $DB {SELECT * FROM t2} -1 DUMMY]
650   sqlite3_step $VM1
651   sqlite3_finalize $VM1
652 } {SQLITE_OK}
654 # Test that passing a NULL pointer to sqlite3_finalize() or sqlite3_reset
655 # does not cause an error.
656 do_test capi2-10.1 {
657   sqlite3_finalize 0
658 } {SQLITE_OK}
659 do_test capi2-10.2 {
660   sqlite3_reset 0
661 } {SQLITE_OK}
663 #---------------------------------------------------------------------------
664 # The following tests - capi2-11.* - test the "column origin" APIs.
666 #   sqlite3_column_origin_name()
667 #   sqlite3_column_database_name()
668 #   sqlite3_column_table_name()
671 ifcapable columnmetadata {
673 # This proc uses the database handle $::DB to compile the SQL statement passed
674 # as a parameter. The return value of this procedure is a list with one
675 # element for each column returned by the compiled statement. Each element of
676 # this list is itself a list of length three, consisting of the origin
677 # database, table and column for the corresponding returned column.
678 proc check_origins {sql} {
679   set ret [list]
680   set ::STMT [sqlite3_prepare $::DB $sql -1 dummy]
681   for {set i 0} {$i < [sqlite3_column_count $::STMT]} {incr i} {
682     lappend ret [list                           \
683       [sqlite3_column_database_name $::STMT $i] \
684       [sqlite3_column_table_name $::STMT $i]    \
685       [sqlite3_column_origin_name $::STMT $i]   \
686     ]
687   }
688   sqlite3_finalize $::STMT
689   return $ret
691 do_test capi2-11.1 {
692   execsql {
693     CREATE TABLE tab1(col1, col2);
694   }
695 } {}
696 do_test capi2-11.2 {
697   check_origins {SELECT col2, col1 FROM tab1}
698 } [list {main tab1 col2} {main tab1 col1}]
699 do_test capi2-11.3 {
700   check_origins {SELECT col2 AS hello, col1 AS world FROM tab1}
701 } [list {main tab1 col2} {main tab1 col1}]
703 ifcapable subquery {
704   do_test capi2-11.4 {
705     check_origins {SELECT b, a FROM (SELECT col1 AS a, col2 AS b FROM tab1)}
706   } [list {main tab1 col2} {main tab1 col1}]
707   do_test capi2-11.5 {
708     check_origins {SELECT (SELECT col2 FROM tab1), (SELECT col1 FROM tab1)}
709   } [list {main tab1 col2} {main tab1 col1}]
710   do_test capi2-11.6 {
711     check_origins {SELECT (SELECT col2), (SELECT col1) FROM tab1}
712   } [list {main tab1 col2} {main tab1 col1}]
713   do_test capi2-11.7 {
714     check_origins {SELECT * FROM tab1}
715   } [list {main tab1 col1} {main tab1 col2}]
716   do_test capi2-11.8 {
717     check_origins {SELECT * FROM (SELECT * FROM tab1)}
718   } [list {main tab1 col1} {main tab1 col2}]
721 ifcapable view&&subquery {
722   do_test capi2-12.1 {
723     execsql {
724       CREATE VIEW view1 AS SELECT * FROM  tab1;
725     }
726   } {}
727   do_test capi2-12.2 {
728     check_origins {SELECT col2, col1 FROM view1}
729   } [list {main tab1 col2} {main tab1 col1}]
730   do_test capi2-12.3 {
731     check_origins {SELECT col2 AS hello, col1 AS world FROM view1}
732   } [list {main tab1 col2} {main tab1 col1}]
733   do_test capi2-12.4 {
734     check_origins {SELECT b, a FROM (SELECT col1 AS a, col2 AS b FROM view1)}
735   } [list {main tab1 col2} {main tab1 col1}]
736   do_test capi2-12.5 {
737     check_origins {SELECT (SELECT col2 FROM view1), (SELECT col1 FROM view1)}
738   } [list {main tab1 col2} {main tab1 col1}]
739   do_test capi2-12.6 {
740     check_origins {SELECT (SELECT col2), (SELECT col1) FROM view1}
741   } [list {main tab1 col2} {main tab1 col1}]
742   do_test capi2-12.7 {
743     check_origins {SELECT * FROM view1}
744   } [list {main tab1 col1} {main tab1 col2}]
745   do_test capi2-12.8 {
746     check_origins {select * from (select * from view1)}
747   } [list {main tab1 col1} {main tab1 col2}]
748   do_test capi2-12.9 {
749     check_origins {select * from (select * from (select * from view1))}
750   } [list {main tab1 col1} {main tab1 col2}]
751   do_test capi2-12.10 {
752     db close
753     sqlite3 db test.db
754     set ::DB [sqlite3_connection_pointer db]
755     check_origins {select * from (select * from (select * from view1))}
756   } [list {main tab1 col1} {main tab1 col2}]
757   
758   # This view will thwart the flattening optimization.
759   do_test capi2-13.1 {
760     execsql {
761       CREATE VIEW view2 AS SELECT * FROM tab1 limit 10 offset 10;
762     }
763   } {}
764   do_test capi2-13.2 {
765     check_origins {SELECT col2, col1 FROM view2}
766   } [list {main tab1 col2} {main tab1 col1}]
767   do_test capi2-13.3 {
768     check_origins {SELECT col2 AS hello, col1 AS world FROM view2}
769   } [list {main tab1 col2} {main tab1 col1}]
770   do_test capi2-13.4 {
771     check_origins {SELECT b, a FROM (SELECT col1 AS a, col2 AS b FROM view2)}
772   } [list {main tab1 col2} {main tab1 col1}]
773   do_test capi2-13.5 {
774     check_origins {SELECT (SELECT col2 FROM view2), (SELECT col1 FROM view2)}
775   } [list {main tab1 col2} {main tab1 col1}]
776   do_test capi2-13.6 {
777     check_origins {SELECT (SELECT col2), (SELECT col1) FROM view2}
778   } [list {main tab1 col2} {main tab1 col1}]
779   do_test capi2-13.7 {
780     check_origins {SELECT * FROM view2}
781   } [list {main tab1 col1} {main tab1 col2}]
782   do_test capi2-13.8 {
783     check_origins {select * from (select * from view2)}
784   } [list {main tab1 col1} {main tab1 col2}]
785   do_test capi2-13.9 {
786     check_origins {select * from (select * from (select * from view2))}
787   } [list {main tab1 col1} {main tab1 col2}]
788   do_test capi2-13.10 {
789     db close
790     sqlite3 db test.db
791     set ::DB [sqlite3_connection_pointer db]
792     check_origins {select * from (select * from (select * from view2))}
793   } [list {main tab1 col1} {main tab1 col2}]
794   do_test capi2-13.11 {
795     check_origins {select * from (select * from tab1 limit 10 offset 10)}
796   } [list {main tab1 col1} {main tab1 col2}]
800 } ;# ifcapable columnmetadata
802 db2 close
803 finish_test