sqlite3/test/capi2.test

   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: capi2.test,v 1.26 2005/03/29 03:11:00 danielk1977 Exp $
  15 #
  16
  17 set testdir [file dirname $argv0]
  18 source $testdir/tester.tcl
  19
  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
  27 }
  28
  29 # Return the column names followed by declaration types for the result set
  30 # of the SQL statement STMT.
  31 #
  32 # i.e. for:
  33 # CREATE TABLE abc(a text, b integer);
  34 # SELECT * FROM abc;
  35 #
  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
  46 }
  47
  48 # Check basic functionality
  49 #
  50 do_test capi2-1.1 {
  51   db close
  52   set DB [sqlite3 db test.db]
  53   execsql {CREATE TABLE t1(a,b,c)}
  54   set VM [sqlite3_prepare $DB {SELECT name, rowid FROM sqlite_master} -1 TAIL]
  55   set TAIL
  56 } {}
  57 do_test capi2-1.2 {
  58   sqlite3_step $VM
  59 } {SQLITE_ROW}
  60 do_test capi2-1.3 {
  61   sqlite3_data_count $VM
  62 } {2}
  63 do_test capi2-1.4 {
  64   get_row_values $VM
  65 } {t1 1}
  66 do_test capi2-1.5 {
  67   get_column_names $VM
  68 } {name rowid text INTEGER}
  69 do_test capi2-1.6 {
  70   sqlite3_step $VM
  71 } {SQLITE_DONE}
  72 do_test capi2-1.7 {
  73   list [sqlite3_column_count $VM] [get_row_values $VM] [get_column_names $VM]
  74 } {2 {} {name rowid text INTEGER}}
  75 do_test capi2-1.8 {
  76   sqlite3_step $VM
  77 } {SQLITE_MISUSE}
  78
  79 # Update: In v2, once SQLITE_MISUSE is returned the statement handle cannot
  80 # be interrogated for more information. However in v3, since the column
  81 # count, names and types are determined at compile time, these are still
  82 # accessible after an SQLITE_MISUSE error.
  83 do_test capi2-1.9 {
  84   list [sqlite3_column_count $VM] [get_row_values $VM] [get_column_names $VM]
  85 } {2 {} {name rowid text INTEGER}}
  86 do_test capi2-1.10 {
  87   sqlite3_data_count $VM
  88 } {0}
  89
  90 do_test capi2-1.11 {
  91   sqlite3_finalize $VM
  92 } {SQLITE_OK}
  93
  94 # Check to make sure that the "tail" of a multi-statement SQL script
  95 # is returned by sqlite3_prepare.
  96 #
  97 do_test capi2-2.1 {
  98   set SQL {
  99     SELECT name, rowid FROM sqlite_master;
 100     SELECT name, rowid FROM sqlite_master WHERE 0;
 101     -- A comment at the end
 102   }
 103   set VM [sqlite3_prepare $DB $SQL -1 SQL]
 104   set SQL
 105 } {
 106     SELECT name, rowid FROM sqlite_master WHERE 0;
 107     -- A comment at the end
 108   }
 109 do_test capi2-2.2 {
 110   set r [sqlite3_step $VM]
 111   lappend r [sqlite3_column_count $VM] \
 112             [get_row_values $VM] \
 113             [get_column_names $VM]
 114 } {SQLITE_ROW 2 {t1 1} {name rowid text INTEGER}}
 115 do_test capi2-2.3 {
 116   set r [sqlite3_step $VM]
 117   lappend r [sqlite3_column_count $VM] \
 118             [get_row_values $VM] \
 119             [get_column_names $VM]
 120 } {SQLITE_DONE 2 {} {name rowid text INTEGER}}
 121 do_test capi2-2.4 {
 122   sqlite3_finalize $VM
 123 } {SQLITE_OK}
 124 do_test capi2-2.5 {
 125   set VM [sqlite3_prepare $DB $SQL -1 SQL]
 126   set SQL
 127 } {
 128     -- A comment at the end
 129   }
 130 do_test capi2-2.6 {
 131   set r [sqlite3_step $VM]
 132   lappend r [sqlite3_column_count $VM] \
 133             [get_row_values $VM] \
 134             [get_column_names $VM]
 135 } {SQLITE_DONE 2 {} {name rowid text INTEGER}}
 136 do_test capi2-2.7 {
 137   sqlite3_finalize $VM
 138 } {SQLITE_OK}
 139 do_test capi2-2.8 {
 140   set VM [sqlite3_prepare $DB $SQL -1 SQL]
 141   list $SQL $VM
 142 } {{} {}}
 143
 144 # Check the error handling.
 145 #
 146 do_test capi2-3.1 {
 147   set rc [catch {
 148       sqlite3_prepare $DB {select bogus from sqlite_master} -1 TAIL
 149   } msg]
 150   lappend rc $msg $TAIL
 151 } {1 {(1) no such column: bogus} {}}
 152 do_test capi2-3.2 {
 153   set rc [catch {
 154       sqlite3_prepare $DB {select bogus from } -1 TAIL
 155   } msg]
 156   lappend rc $msg $TAIL
 157 } {1 {(1) near " ": syntax error} {}}
 158 do_test capi2-3.3 {
 159   set rc [catch {
 160       sqlite3_prepare $DB {;;;;select bogus from sqlite_master} -1 TAIL
 161   } msg]
 162   lappend rc $msg $TAIL
 163 } {1 {(1) no such column: bogus} {}}
 164 do_test capi2-3.4 {
 165   set rc [catch {
 166       sqlite3_prepare $DB {select bogus from sqlite_master;x;} -1 TAIL
 167   } msg]
 168   lappend rc $msg $TAIL
 169 } {1 {(1) no such column: bogus} {x;}}
 170 do_test capi2-3.5 {
 171   set rc [catch {
 172       sqlite3_prepare $DB {select bogus from sqlite_master;;;x;} -1 TAIL
 173   } msg]
 174   lappend rc $msg $TAIL
 175 } {1 {(1) no such column: bogus} {;;x;}}
 176 do_test capi2-3.6 {
 177   set rc [catch {
 178       sqlite3_prepare $DB {select 5/0} -1 TAIL
 179   } VM]
 180   lappend rc $TAIL
 181 } {0 {}}
 182 do_test capi2-3.7 {
 183   list [sqlite3_step $VM] \
 184        [sqlite3_column_count $VM] \
 185        [get_row_values $VM] \
 186        [get_column_names $VM]
 187 } {SQLITE_ROW 1 {{}} {5/0 {}}}
 188 do_test capi2-3.8 {
 189   sqlite3_finalize $VM
 190 } {SQLITE_OK}
 191 do_test capi2-3.9 {
 192   execsql {CREATE UNIQUE INDEX i1 ON t1(a)}
 193   set VM [sqlite3_prepare $DB {INSERT INTO t1 VALUES(1,2,3)} -1 TAIL]
 194   set TAIL
 195 } {}
 196 do_test capi2-3.9b {db changes} {0}
 197 do_test capi2-3.10 {
 198   list [sqlite3_step $VM] \
 199        [sqlite3_column_count $VM] \
 200        [get_row_values $VM] \
 201        [get_column_names $VM]
 202 } {SQLITE_DONE 0 {} {}}
 203
 204 # Update for v3 - the change has not actually happened until the query is
 205 # finalized. Is this going to cause trouble for anyone? Lee Nelson maybe?
 206 # (Later:) The change now happens just before SQLITE_DONE is returned.
 207 do_test capi2-3.10b {db changes} {1}
 208 do_test capi2-3.11 {
 209   sqlite3_finalize $VM
 210 } {SQLITE_OK}
 211 do_test capi2-3.11b {db changes} {1}
 212 do_test capi2-3.12 {
 213   sqlite3_finalize $VM
 214 } {SQLITE_MISUSE}
 215 do_test capi2-3.13 {
 216   set VM [sqlite3_prepare $DB {INSERT INTO t1 VALUES(1,3,4)} -1 TAIL]
 217   list [sqlite3_step $VM] \
 218        [sqlite3_column_count $VM] \
 219        [get_row_values $VM] \
 220        [get_column_names $VM]
 221 } {SQLITE_ERROR 0 {} {}}
 222
 223 # Update for v3: Preparing a statement does not affect the change counter.
 224 # (Test result changes from 0 to 1).  (Later:) change counter updates occur
 225 # when sqlite3_step returns, not at finalize time.
 226 do_test capi2-3.13b {db changes} {0}
 227
 228 do_test capi2-3.14 {
 229   list [sqlite3_finalize $VM] [sqlite3_errmsg $DB]
 230 } {SQLITE_CONSTRAINT {column a is not unique}}
 231 do_test capi2-3.15 {
 232   set VM [sqlite3_prepare $DB {CREATE TABLE t2(a NOT NULL, b)} -1 TAIL]
 233   set TAIL
 234 } {}
 235 do_test capi2-3.16 {
 236   list [sqlite3_step $VM] \
 237        [sqlite3_column_count $VM] \
 238        [get_row_values $VM] \
 239        [get_column_names $VM]
 240 } {SQLITE_DONE 0 {} {}}
 241 do_test capi2-3.17 {
 242   list [sqlite3_finalize $VM] [sqlite3_errmsg $DB]
 243 } {SQLITE_OK {not an error}}
 244 do_test capi2-3.18 {
 245   set VM [sqlite3_prepare $DB {INSERT INTO t2 VALUES(NULL,2)} -1 TAIL]
 246   list [sqlite3_step $VM] \
 247        [sqlite3_column_count $VM] \
 248        [get_row_values $VM] \
 249        [get_column_names $VM]
 250 } {SQLITE_ERROR 0 {} {}}
 251 do_test capi2-3.19 {
 252   list [sqlite3_finalize $VM] [sqlite3_errmsg $DB]
 253 } {SQLITE_CONSTRAINT {t2.a may not be NULL}}
 254
 255 do_test capi2-3.20 {
 256   execsql {
 257     CREATE TABLE a1(message_id, name , UNIQUE(message_id, name) );
 258     INSERT INTO a1 VALUES(1, 1);
 259   }
 260 } {}
 261 do_test capi2-3.21 {
 262   set VM [sqlite3_prepare $DB {INSERT INTO a1 VALUES(1, 1)} -1 TAIL]
 263   sqlite3_step $VM
 264 } {SQLITE_ERROR}
 265 do_test capi2-3.22 {
 266   sqlite3_errcode $DB
 267 } {SQLITE_ERROR}
 268 do_test capi2-3.23 {
 269   sqlite3_finalize $VM
 270 } {SQLITE_CONSTRAINT}
 271 do_test capi2-3.24 {
 272   sqlite3_errcode $DB
 273 } {SQLITE_CONSTRAINT}
 274
 275 # Two or more virtual machines exists at the same time.
 276 #
 277 do_test capi2-4.1 {
 278   set VM1 [sqlite3_prepare $DB {INSERT INTO t2 VALUES(1,2)} -1 TAIL]
 279   set TAIL
 280 } {}
 281 do_test capi2-4.2 {
 282   set VM2 [sqlite3_prepare $DB {INSERT INTO t2 VALUES(2,3)} -1 TAIL]
 283   set TAIL
 284 } {}
 285 do_test capi2-4.3 {
 286   set VM3 [sqlite3_prepare $DB {INSERT INTO t2 VALUES(3,4)} -1 TAIL]
 287   set TAIL
 288 } {}
 289 do_test capi2-4.4 {
 290   list [sqlite3_step $VM2] \
 291        [sqlite3_column_count $VM2] \
 292        [get_row_values $VM2] \
 293        [get_column_names $VM2]
 294 } {SQLITE_DONE 0 {} {}}
 295 do_test capi2-4.5 {
 296   execsql {SELECT * FROM t2 ORDER BY a}
 297 } {2 3}
 298 do_test capi2-4.6 {
 299   sqlite3_finalize $VM2
 300 } {SQLITE_OK}
 301 do_test capi2-4.7 {
 302   list [sqlite3_step $VM3] \
 303        [sqlite3_column_count $VM3] \
 304        [get_row_values $VM3] \
 305        [get_column_names $VM3]
 306 } {SQLITE_DONE 0 {} {}}
 307 do_test capi2-4.8 {
 308   execsql {SELECT * FROM t2 ORDER BY a}
 309 } {2 3 3 4}
 310 do_test capi2-4.9 {
 311   sqlite3_finalize $VM3
 312 } {SQLITE_OK}
 313 do_test capi2-4.10 {
 314   list [sqlite3_step $VM1] \
 315        [sqlite3_column_count $VM1] \
 316        [get_row_values $VM1] \
 317        [get_column_names $VM1]
 318 } {SQLITE_DONE 0 {} {}}
 319 do_test capi2-4.11 {
 320   execsql {SELECT * FROM t2 ORDER BY a}
 321 } {1 2 2 3 3 4}
 322 do_test capi2-4.12 {
 323   sqlite3_finalize $VM1
 324 } {SQLITE_OK}
 325
 326 # Interleaved SELECTs
 327 #
 328 do_test capi2-5.1 {
 329   set VM1 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
 330   set VM2 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
 331   set VM3 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
 332   list [sqlite3_step $VM1] \
 333        [sqlite3_column_count $VM1] \
 334        [get_row_values $VM1] \
 335        [get_column_names $VM1]
 336 } {SQLITE_ROW 2 {2 3} {a b {} {}}}
 337 do_test capi2-5.2 {
 338   list [sqlite3_step $VM2] \
 339        [sqlite3_column_count $VM2] \
 340        [get_row_values $VM2] \
 341        [get_column_names $VM2]
 342 } {SQLITE_ROW 2 {2 3} {a b {} {}}}
 343 do_test capi2-5.3 {
 344   list [sqlite3_step $VM1] \
 345        [sqlite3_column_count $VM1] \
 346        [get_row_values $VM1] \
 347        [get_column_names $VM1]
 348 } {SQLITE_ROW 2 {3 4} {a b {} {}}}
 349 do_test capi2-5.4 {
 350   list [sqlite3_step $VM3] \
 351        [sqlite3_column_count $VM3] \
 352        [get_row_values $VM3] \
 353        [get_column_names $VM3]
 354 } {SQLITE_ROW 2 {2 3} {a b {} {}}}
 355 do_test capi2-5.5 {
 356   list [sqlite3_step $VM3] \
 357        [sqlite3_column_count $VM3] \
 358        [get_row_values $VM3] \
 359        [get_column_names $VM3]
 360 } {SQLITE_ROW 2 {3 4} {a b {} {}}}
 361 do_test capi2-5.6 {
 362   list [sqlite3_step $VM3] \
 363        [sqlite3_column_count $VM3] \
 364        [get_row_values $VM3] \
 365        [get_column_names $VM3]
 366 } {SQLITE_ROW 2 {1 2} {a b {} {}}}
 367 do_test capi2-5.7 {
 368   list [sqlite3_step $VM3] \
 369        [sqlite3_column_count $VM3] \
 370        [get_row_values $VM3] \
 371        [get_column_names $VM3]
 372 } {SQLITE_DONE 2 {} {a b {} {}}}
 373 do_test capi2-5.8 {
 374   sqlite3_finalize $VM3
 375 } {SQLITE_OK}
 376 do_test capi2-5.9 {
 377   list [sqlite3_step $VM1] \
 378        [sqlite3_column_count $VM1] \
 379        [get_row_values $VM1] \
 380        [get_column_names $VM1]
 381 } {SQLITE_ROW 2 {1 2} {a b {} {}}}
 382 do_test capi2-5.10 {
 383   sqlite3_finalize $VM1
 384 } {SQLITE_OK}
 385 do_test capi2-5.11 {
 386   list [sqlite3_step $VM2] \
 387        [sqlite3_column_count $VM2] \
 388        [get_row_values $VM2] \
 389        [get_column_names $VM2]
 390 } {SQLITE_ROW 2 {3 4} {a b {} {}}}
 391 do_test capi2-5.12 {
 392   list [sqlite3_step $VM2] \
 393        [sqlite3_column_count $VM2] \
 394        [get_row_values $VM2] \
 395        [get_column_names $VM2]
 396 } {SQLITE_ROW 2 {1 2} {a b {} {}}}
 397 do_test capi2-5.11 {
 398   sqlite3_finalize $VM2
 399 } {SQLITE_OK}
 400
 401 # Check for proper SQLITE_BUSY returns.
 402 #
 403 do_test capi2-6.1 {
 404   execsql {
 405     BEGIN;
 406     CREATE TABLE t3(x counter);
 407     INSERT INTO t3 VALUES(1);
 408     INSERT INTO t3 VALUES(2);
 409     INSERT INTO t3 SELECT x+2 FROM t3;
 410     INSERT INTO t3 SELECT x+4 FROM t3;
 411     INSERT INTO t3 SELECT x+8 FROM t3;
 412     COMMIT;
 413   }
 414   set VM1 [sqlite3_prepare $DB {SELECT * FROM t3} -1 TAIL]
 415   sqlite3 db2 test.db
 416   execsql {BEGIN} db2
 417 } {}
 418 # Update for v3: BEGIN doesn't write-lock the database. It is quite
 419 # difficult to get v3 to write-lock the database, which causes a few
 420 # problems for test scripts.
 421 #
 422 # do_test capi2-6.2 {
 423 #   list [sqlite3_step $VM1] \
 424 #        [sqlite3_column_count $VM1] \
 425 #        [get_row_values $VM1] \
 426 #        [get_column_names $VM1]
 427 # } {SQLITE_BUSY 0 {} {}}
 428 do_test capi2-6.3 {
 429   execsql {COMMIT} db2
 430 } {}
 431 do_test capi2-6.4 {
 432   list [sqlite3_step $VM1] \
 433        [sqlite3_column_count $VM1] \
 434        [get_row_values $VM1] \
 435        [get_column_names $VM1]
 436 } {SQLITE_ROW 1 1 {x counter}}
 437 do_test capi2-6.5 {
 438   catchsql {INSERT INTO t3 VALUES(10);} db2
 439 } {1 {database is locked}}
 440 do_test capi2-6.6 {
 441   list [sqlite3_step $VM1] \
 442        [sqlite3_column_count $VM1] \
 443        [get_row_values $VM1] \
 444        [get_column_names $VM1]
 445 } {SQLITE_ROW 1 2 {x counter}}
 446 do_test capi2-6.7 {
 447   execsql {SELECT * FROM t2} db2
 448 } {2 3 3 4 1 2}
 449 do_test capi2-6.8 {
 450   list [sqlite3_step $VM1] \
 451        [sqlite3_column_count $VM1] \
 452        [get_row_values $VM1] \
 453        [get_column_names $VM1]
 454 } {SQLITE_ROW 1 3 {x counter}}
 455 do_test capi2-6.9 {
 456   execsql {SELECT * FROM t2}
 457 } {2 3 3 4 1 2}
 458 do_test capi2-6.10 {
 459   list [sqlite3_step $VM1] \
 460        [sqlite3_column_count $VM1] \
 461        [get_row_values $VM1] \
 462        [get_column_names $VM1]
 463 } {SQLITE_ROW 1 4 {x counter}}
 464 do_test capi2-6.11 {
 465   execsql {BEGIN}
 466 } {}
 467 do_test capi2-6.12 {
 468   list [sqlite3_step $VM1] \
 469        [sqlite3_column_count $VM1] \
 470        [get_row_values $VM1] \
 471        [get_column_names $VM1]
 472 } {SQLITE_ROW 1 5 {x counter}}
 473
 474 do_test capi2-6.13 {
 475   catchsql {UPDATE t3 SET x=x+1}
 476 } {1 {database table is locked}}
 477 do_test capi2-6.14 {
 478   list [sqlite3_step $VM1] \
 479        [sqlite3_column_count $VM1] \
 480        [get_row_values $VM1] \
 481        [get_column_names $VM1]
 482 } {SQLITE_ROW 1 6 {x counter}}
 483 do_test capi2-6.15 {
 484   execsql {SELECT * FROM t1}
 485 } {1 2 3}
 486 do_test capi2-6.16 {
 487   list [sqlite3_step $VM1] \
 488        [sqlite3_column_count $VM1] \
 489        [get_row_values $VM1] \
 490        [get_column_names $VM1]
 491 } {SQLITE_ROW 1 7 {x counter}}
 492 do_test capi2-6.17 {
 493   catchsql {UPDATE t1 SET b=b+1}
 494 } {0 {}}
 495 do_test capi2-6.18 {
 496   list [sqlite3_step $VM1] \
 497        [sqlite3_column_count $VM1] \
 498        [get_row_values $VM1] \
 499        [get_column_names $VM1]
 500 } {SQLITE_ROW 1 8 {x counter}}
 501 do_test capi2-6.19 {
 502   execsql {SELECT * FROM t1}
 503 } {1 3 3}
 504 do_test capi2-6.20 {
 505   list [sqlite3_step $VM1] \
 506        [sqlite3_column_count $VM1] \
 507        [get_row_values $VM1] \
 508        [get_column_names $VM1]
 509 } {SQLITE_ROW 1 9 {x counter}}
 510 #do_test capi2-6.21 {
 511 #  execsql {ROLLBACK; SELECT * FROM t1}
 512 #} {1 2 3}
 513 do_test capi2-6.22 {
 514   list [sqlite3_step $VM1] \
 515        [sqlite3_column_count $VM1] \
 516        [get_row_values $VM1] \
 517        [get_column_names $VM1]
 518 } {SQLITE_ROW 1 10 {x counter}}
 519 #do_test capi2-6.23 {
 520 #  execsql {BEGIN TRANSACTION;}
 521 #} {}
 522 do_test capi2-6.24 {
 523   list [sqlite3_step $VM1] \
 524        [sqlite3_column_count $VM1] \
 525        [get_row_values $VM1] \
 526        [get_column_names $VM1]
 527 } {SQLITE_ROW 1 11 {x counter}}
 528 do_test capi2-6.25 {
 529   execsql {
 530     INSERT INTO t1 VALUES(2,3,4);
 531     SELECT * FROM t1;
 532   }
 533 } {1 3 3 2 3 4}
 534 do_test capi2-6.26 {
 535   list [sqlite3_step $VM1] \
 536        [sqlite3_column_count $VM1] \
 537        [get_row_values $VM1] \
 538        [get_column_names $VM1]
 539 } {SQLITE_ROW 1 12 {x counter}}
 540 do_test capi2-6.27 {
 541   catchsql {
 542     INSERT INTO t1 VALUES(2,4,5);
 543     SELECT * FROM t1;
 544   }
 545 } {1 {column a is not unique}}
 546 do_test capi2-6.28 {
 547   list [sqlite3_step $VM1] \
 548        [sqlite3_column_count $VM1] \
 549        [get_row_values $VM1] \
 550        [get_column_names $VM1]
 551 } {SQLITE_ROW 1 13 {x counter}}
 552 do_test capi2-6.99 {
 553   sqlite3_finalize $VM1
 554 } {SQLITE_OK}
 555 catchsql {ROLLBACK}
 556
 557 do_test capi2-7.1 {
 558   stepsql $DB {
 559     SELECT * FROM t1
 560   }
 561 } {0 1 2 3}
 562 do_test capi2-7.2 {
 563   stepsql $DB {
 564     PRAGMA count_changes=on
 565   }
 566 } {0}
 567 do_test capi2-7.3 {
 568   stepsql $DB {
 569     UPDATE t1 SET a=a+10;
 570   }
 571 } {0 1}
 572 do_test capi2-7.4 {
 573   stepsql $DB {
 574     INSERT INTO t1 SELECT a+1,b+1,c+1 FROM t1;
 575   }
 576 } {0 1}
 577 do_test capi2-7.4b {sqlite3_changes $DB} {1}
 578 do_test capi2-7.5 {
 579   stepsql $DB {
 580     UPDATE t1 SET a=a+10;
 581   }
 582 } {0 2}
 583 do_test capi2-7.5b {sqlite3_changes $DB} {2}
 584 do_test capi2-7.6 {
 585   stepsql $DB {
 586     SELECT * FROM t1;
 587   }
 588 } {0 21 2 3 22 3 4}
 589 do_test capi2-7.7 {
 590   stepsql $DB {
 591     INSERT INTO t1 SELECT a+2,b+2,c+2 FROM t1;
 592   }
 593 } {0 2}
 594 do_test capi2-7.8 {
 595   sqlite3_changes $DB
 596 } {2}
 597 do_test capi2-7.9 {
 598   stepsql $DB {
 599     SELECT * FROM t1;
 600   }
 601 } {0 21 2 3 22 3 4 23 4 5 24 5 6}
 602 do_test capi2-7.10 {
 603   stepsql $DB {
 604     UPDATE t1 SET a=a-20;
 605     SELECT * FROM t1;
 606   }
 607 } {0 4 1 2 3 2 3 4 3 4 5 4 5 6}
 608
 609 # Update for version 3: A SELECT statement no longer resets the change
 610 # counter (Test result changes from 0 to 4).
 611 do_test capi2-7.11 {
 612   sqlite3_changes $DB
 613 } {4}
 614 do_test capi2-7.11a {
 615   execsql {SELECT count(*) FROM t1}
 616 } {4}
 617
 618 ifcapable {explain} {
 619   do_test capi2-7.12 {
 620 btree_breakpoint
 621     set x [stepsql $DB {EXPLAIN SELECT * FROM t1}]
 622     lindex $x 0
 623   } {0}
 624 }
 625
 626 # Ticket #261 - make sure we can finalize before the end of a query.
 627 #
 628 do_test capi2-8.1 {
 629   set VM1 [sqlite3_prepare $DB {SELECT * FROM t2} -1 TAIL]
 630   sqlite3_finalize $VM1
 631 } {SQLITE_OK}
 632
 633 # Tickets #384 and #385 - make sure the TAIL argument to sqlite3_prepare
 634 # and all of the return pointers in sqlite_step can be null.
 635 #
 636 do_test capi2-9.1 {
 637   set VM1 [sqlite3_prepare $DB {SELECT * FROM t2} -1 DUMMY]
 638   sqlite3_step $VM1
 639   sqlite3_finalize $VM1
 640 } {SQLITE_OK}
 641
 642 do_test capi2-10.1 {
 643   sqlite3_finalize 0
 644 } {SQLITE_OK}
 645 do_test capi2-10.2 {
 646   sqlite3_reset 0
 647 } {SQLITE_OK}
 648
 649 db2 close
 650
 651 finish_test