Annotation of embedaddon/sqlite3/test/capi3c.test, revision 1.1
1.1 ! misho 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: forcedelete 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: forcedelete 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: forcedelete test.db
! 716: forcedelete 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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to capi3c.test CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test