PageRenderTime 44ms CodeModel.GetById 12ms RepoModel.GetById 0ms app.codeStats 0ms

/test/capi3c.test

https://bitbucket.org/aware/sqlite
Unknown | 1372 lines | 1280 code | 92 blank | 0 comment | 0 complexity | e2ef8083dc9a52c96a4f732241fb68c0 MD5 | raw file
  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:$
  17. #
  18. set testdir [file dirname $argv0]
  19. source $testdir/tester.tcl
  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. # Return the UTF-16 representation of the supplied UTF-8 string $str.
  25. # If $nt is true, append two 0x00 bytes as a nul terminator.
  26. proc utf16 {str {nt 1}} {
  27. set r [encoding convertto unicode $str]
  28. if {$nt} {
  29. append r "\x00\x00"
  30. }
  31. return $r
  32. }
  33. # Return the UTF-8 representation of the supplied UTF-16 string $str.
  34. proc utf8 {str} {
  35. # If $str ends in two 0x00 0x00 bytes, knock these off before
  36. # converting to UTF-8 using TCL.
  37. binary scan $str \c* vals
  38. if {[lindex $vals end]==0 && [lindex $vals end-1]==0} {
  39. set str [binary format \c* [lrange $vals 0 end-2]]
  40. }
  41. set r [encoding convertfrom unicode $str]
  42. return $r
  43. }
  44. # These tests complement those in capi2.test. They are organized
  45. # as follows:
  46. #
  47. # capi3c-1.*: Test sqlite3_prepare_v2
  48. # capi3c-2.*: Test sqlite3_prepare16_v2
  49. # capi3c-3.*: Test sqlite3_open
  50. # capi3c-4.*: Test sqlite3_open16
  51. # capi3c-5.*: Test the various sqlite3_result_* APIs
  52. # capi3c-6.*: Test that sqlite3_close fails if there are outstanding VMs.
  53. #
  54. set DB [sqlite3_connection_pointer db]
  55. do_test capi3c-1.0 {
  56. sqlite3_get_autocommit $DB
  57. } 1
  58. do_test capi3c-1.1 {
  59. set STMT [sqlite3_prepare_v2 $DB {SELECT name FROM sqlite_master} -1 TAIL]
  60. sqlite3_finalize $STMT
  61. set TAIL
  62. } {}
  63. do_test capi3c-1.2.1 {
  64. sqlite3_errcode $DB
  65. } {SQLITE_OK}
  66. do_test capi3c-1.2.2 {
  67. sqlite3_extended_errcode $DB
  68. } {SQLITE_OK}
  69. do_test capi3c-1.3 {
  70. sqlite3_errmsg $DB
  71. } {not an error}
  72. do_test capi3c-1.4 {
  73. set sql {SELECT name FROM sqlite_master;SELECT 10}
  74. set STMT [sqlite3_prepare_v2 $DB $sql -1 TAIL]
  75. sqlite3_finalize $STMT
  76. set TAIL
  77. } {SELECT 10}
  78. do_test capi3c-1.5 {
  79. set sql {SELECT namex FROM sqlite_master}
  80. catch {
  81. set STMT [sqlite3_prepare_v2 $DB $sql -1 TAIL]
  82. }
  83. } {1}
  84. do_test capi3c-1.6.1 {
  85. sqlite3_errcode $DB
  86. } {SQLITE_ERROR}
  87. do_test capi3c-1.6.2 {
  88. sqlite3_extended_errcode $DB
  89. } {SQLITE_ERROR}
  90. do_test capi3c-1.7 {
  91. sqlite3_errmsg $DB
  92. } {no such column: namex}
  93. ifcapable {utf16} {
  94. do_test capi3c-2.1 {
  95. set sql16 [utf16 {SELECT name FROM sqlite_master}]
  96. set STMT [sqlite3_prepare16_v2 $DB $sql16 -1 ::TAIL]
  97. sqlite3_finalize $STMT
  98. utf8 $::TAIL
  99. } {}
  100. do_test capi3c-2.2 {
  101. set sql [utf16 {SELECT name FROM sqlite_master;SELECT 10}]
  102. set STMT [sqlite3_prepare16_v2 $DB $sql -1 TAIL]
  103. sqlite3_finalize $STMT
  104. utf8 $TAIL
  105. } {SELECT 10}
  106. do_test capi3c-2.3 {
  107. set sql [utf16 {SELECT namex FROM sqlite_master}]
  108. catch {
  109. set STMT [sqlite3_prepare16_v2 $DB $sql -1 TAIL]
  110. }
  111. } {1}
  112. do_test capi3c-2.4.1 {
  113. sqlite3_errcode $DB
  114. } {SQLITE_ERROR}
  115. do_test capi3c-2.4.2 {
  116. sqlite3_extended_errcode $DB
  117. } {SQLITE_ERROR}
  118. do_test capi3c-2.5 {
  119. sqlite3_errmsg $DB
  120. } {no such column: namex}
  121. ifcapable schema_pragmas {
  122. do_test capi3c-2.6 {
  123. execsql {CREATE TABLE tablename(x)}
  124. set sql16 [utf16 {PRAGMA table_info("TableName")}]
  125. set STMT [sqlite3_prepare16_v2 $DB $sql16 -1 TAIL]
  126. sqlite3_step $STMT
  127. } SQLITE_ROW
  128. do_test capi3c-2.7 {
  129. sqlite3_step $STMT
  130. } SQLITE_DONE
  131. do_test capi3c-2.8 {
  132. sqlite3_finalize $STMT
  133. } SQLITE_OK
  134. }
  135. } ;# endif utf16
  136. # rename sqlite3_open sqlite3_open_old
  137. # proc sqlite3_open {fname options} {sqlite3_open_new $fname $options}
  138. do_test capi3c-3.1 {
  139. set db2 [sqlite3_open test.db {}]
  140. sqlite3_errcode $db2
  141. } {SQLITE_OK}
  142. # FIX ME: Should test the db handle works.
  143. do_test capi3c-3.2 {
  144. sqlite3_close $db2
  145. } {SQLITE_OK}
  146. do_test capi3c-3.3 {
  147. catch {
  148. set db2 [sqlite3_open /bogus/path/test.db {}]
  149. }
  150. sqlite3_errcode $db2
  151. } {SQLITE_CANTOPEN}
  152. do_test capi3c-3.4 {
  153. sqlite3_errmsg $db2
  154. } {unable to open database file}
  155. do_test capi3c-3.5 {
  156. sqlite3_close $db2
  157. } {SQLITE_OK}
  158. do_test capi3c-3.6.1-misuse {
  159. sqlite3_close $db2
  160. } {SQLITE_MISUSE}
  161. do_test capi3c-3.6.2-misuse {
  162. sqlite3_errmsg $db2
  163. } {library routine called out of sequence}
  164. ifcapable {utf16} {
  165. do_test capi3c-3.6.3-misuse {
  166. utf8 [sqlite3_errmsg16 $db2]
  167. } {library routine called out of sequence}
  168. }
  169. # rename sqlite3_open ""
  170. # rename sqlite3_open_old sqlite3_open
  171. ifcapable {utf16} {
  172. do_test capi3c-4.1 {
  173. set db2 [sqlite3_open16 [utf16 test.db] {}]
  174. sqlite3_errcode $db2
  175. } {SQLITE_OK}
  176. # FIX ME: Should test the db handle works.
  177. do_test capi3c-4.2 {
  178. sqlite3_close $db2
  179. } {SQLITE_OK}
  180. do_test capi3c-4.3 {
  181. catch {
  182. set db2 [sqlite3_open16 [utf16 /bogus/path/test.db] {}]
  183. }
  184. sqlite3_errcode $db2
  185. } {SQLITE_CANTOPEN}
  186. do_test capi3c-4.4 {
  187. utf8 [sqlite3_errmsg16 $db2]
  188. } {unable to open database file}
  189. do_test capi3c-4.5 {
  190. sqlite3_close $db2
  191. } {SQLITE_OK}
  192. } ;# utf16
  193. # This proc is used to test the following API calls:
  194. #
  195. # sqlite3_column_count
  196. # sqlite3_column_name
  197. # sqlite3_column_name16
  198. # sqlite3_column_decltype
  199. # sqlite3_column_decltype16
  200. #
  201. # $STMT is a compiled SQL statement. $test is a prefix
  202. # to use for test names within this proc. $names is a list
  203. # of the column names that should be returned by $STMT.
  204. # $decltypes is a list of column declaration types for $STMT.
  205. #
  206. # Example:
  207. #
  208. # set STMT [sqlite3_prepare_v2 "SELECT 1, 2, 2;" -1 DUMMY]
  209. # check_header test1.1 {1 2 3} {"" "" ""}
  210. #
  211. proc check_header {STMT test names decltypes} {
  212. # Use the return value of sqlite3_column_count() to build
  213. # a list of column indexes. i.e. If sqlite3_column_count
  214. # is 3, build the list {0 1 2}.
  215. set ::idxlist [list]
  216. set ::numcols [sqlite3_column_count $STMT]
  217. for {set i 0} {$i < $::numcols} {incr i} {lappend ::idxlist $i}
  218. # Column names in UTF-8
  219. do_test $test.1 {
  220. set cnamelist [list]
  221. foreach i $idxlist {lappend cnamelist [sqlite3_column_name $STMT $i]}
  222. set cnamelist
  223. } $names
  224. # Column names in UTF-16
  225. ifcapable {utf16} {
  226. do_test $test.2 {
  227. set cnamelist [list]
  228. foreach i $idxlist {
  229. lappend cnamelist [utf8 [sqlite3_column_name16 $STMT $i]]
  230. }
  231. set cnamelist
  232. } $names
  233. }
  234. # Column names in UTF-8
  235. do_test $test.3 {
  236. set cnamelist [list]
  237. foreach i $idxlist {lappend cnamelist [sqlite3_column_name $STMT $i]}
  238. set cnamelist
  239. } $names
  240. # Column names in UTF-16
  241. ifcapable {utf16} {
  242. do_test $test.4 {
  243. set cnamelist [list]
  244. foreach i $idxlist {
  245. lappend cnamelist [utf8 [sqlite3_column_name16 $STMT $i]]
  246. }
  247. set cnamelist
  248. } $names
  249. }
  250. # Column names in UTF-8
  251. do_test $test.5 {
  252. set cnamelist [list]
  253. foreach i $idxlist {lappend cnamelist [sqlite3_column_decltype $STMT $i]}
  254. set cnamelist
  255. } $decltypes
  256. # Column declaration types in UTF-16
  257. ifcapable {utf16} {
  258. do_test $test.6 {
  259. set cnamelist [list]
  260. foreach i $idxlist {
  261. lappend cnamelist [utf8 [sqlite3_column_decltype16 $STMT $i]]
  262. }
  263. set cnamelist
  264. } $decltypes
  265. }
  266. # Test some out of range conditions:
  267. ifcapable {utf16} {
  268. do_test $test.7 {
  269. list \
  270. [sqlite3_column_name $STMT -1] \
  271. [sqlite3_column_name16 $STMT -1] \
  272. [sqlite3_column_decltype $STMT -1] \
  273. [sqlite3_column_decltype16 $STMT -1] \
  274. [sqlite3_column_name $STMT $numcols] \
  275. [sqlite3_column_name16 $STMT $numcols] \
  276. [sqlite3_column_decltype $STMT $numcols] \
  277. [sqlite3_column_decltype16 $STMT $numcols]
  278. } {{} {} {} {} {} {} {} {}}
  279. }
  280. }
  281. # This proc is used to test the following API calls:
  282. #
  283. # sqlite3_column_origin_name
  284. # sqlite3_column_origin_name16
  285. # sqlite3_column_table_name
  286. # sqlite3_column_table_name16
  287. # sqlite3_column_database_name
  288. # sqlite3_column_database_name16
  289. #
  290. # $STMT is a compiled SQL statement. $test is a prefix
  291. # to use for test names within this proc. $names is a list
  292. # of the column names that should be returned by $STMT.
  293. # $decltypes is a list of column declaration types for $STMT.
  294. #
  295. # Example:
  296. #
  297. # set STMT [sqlite3_prepare_v2 "SELECT 1, 2, 2;" -1 DUMMY]
  298. # check_header test1.1 {1 2 3} {"" "" ""}
  299. #
  300. proc check_origin_header {STMT test dbs tables cols} {
  301. # If sqlite3_column_origin_name() and friends are not compiled into
  302. # this build, this proc is a no-op.
  303. ifcapable columnmetadata {
  304. # Use the return value of sqlite3_column_count() to build
  305. # a list of column indexes. i.e. If sqlite3_column_count
  306. # is 3, build the list {0 1 2}.
  307. set ::idxlist [list]
  308. set ::numcols [sqlite3_column_count $STMT]
  309. for {set i 0} {$i < $::numcols} {incr i} {lappend ::idxlist $i}
  310. # Database names in UTF-8
  311. do_test $test.8 {
  312. set cnamelist [list]
  313. foreach i $idxlist {
  314. lappend cnamelist [sqlite3_column_database_name $STMT $i]
  315. }
  316. set cnamelist
  317. } $dbs
  318. # Database names in UTF-16
  319. ifcapable {utf16} {
  320. do_test $test.9 {
  321. set cnamelist [list]
  322. foreach i $idxlist {
  323. lappend cnamelist [utf8 [sqlite3_column_database_name16 $STMT $i]]
  324. }
  325. set cnamelist
  326. } $dbs
  327. }
  328. # Table names in UTF-8
  329. do_test $test.10 {
  330. set cnamelist [list]
  331. foreach i $idxlist {
  332. lappend cnamelist [sqlite3_column_table_name $STMT $i]
  333. }
  334. set cnamelist
  335. } $tables
  336. # Table names in UTF-16
  337. ifcapable {utf16} {
  338. do_test $test.11 {
  339. set cnamelist [list]
  340. foreach i $idxlist {
  341. lappend cnamelist [utf8 [sqlite3_column_table_name16 $STMT $i]]
  342. }
  343. set cnamelist
  344. } $tables
  345. }
  346. # Origin names in UTF-8
  347. do_test $test.12 {
  348. set cnamelist [list]
  349. foreach i $idxlist {
  350. lappend cnamelist [sqlite3_column_origin_name $STMT $i]
  351. }
  352. set cnamelist
  353. } $cols
  354. # Origin declaration types in UTF-16
  355. ifcapable {utf16} {
  356. do_test $test.13 {
  357. set cnamelist [list]
  358. foreach i $idxlist {
  359. lappend cnamelist [utf8 [sqlite3_column_origin_name16 $STMT $i]]
  360. }
  361. set cnamelist
  362. } $cols
  363. }
  364. }
  365. }
  366. # This proc is used to test the following APIs:
  367. #
  368. # sqlite3_data_count
  369. # sqlite3_column_type
  370. # sqlite3_column_int
  371. # sqlite3_column_text
  372. # sqlite3_column_text16
  373. # sqlite3_column_double
  374. #
  375. # $STMT is a compiled SQL statement for which the previous call
  376. # to sqlite3_step returned SQLITE_ROW. $test is a prefix to use
  377. # for test names within this proc. $types is a list of the
  378. # manifest types for the current row. $ints, $doubles and $strings
  379. # are lists of the integer, real and string representations of
  380. # the values in the current row.
  381. #
  382. # Example:
  383. #
  384. # set STMT [sqlite3_prepare_v2 "SELECT 'hello', 1.1, NULL" -1 DUMMY]
  385. # sqlite3_step $STMT
  386. # check_data test1.2 {TEXT REAL NULL} {0 1 0} {0 1.1 0} {hello 1.1 {}}
  387. #
  388. proc check_data {STMT test types ints doubles strings} {
  389. # Use the return value of sqlite3_column_count() to build
  390. # a list of column indexes. i.e. If sqlite3_column_count
  391. # is 3, build the list {0 1 2}.
  392. set ::idxlist [list]
  393. set numcols [sqlite3_data_count $STMT]
  394. for {set i 0} {$i < $numcols} {incr i} {lappend ::idxlist $i}
  395. # types
  396. do_test $test.1 {
  397. set types [list]
  398. foreach i $idxlist {lappend types [sqlite3_column_type $STMT $i]}
  399. set types
  400. } $types
  401. # Integers
  402. do_test $test.2 {
  403. set ints [list]
  404. foreach i $idxlist {lappend ints [sqlite3_column_int64 $STMT $i]}
  405. set ints
  406. } $ints
  407. # bytes
  408. set lens [list]
  409. foreach i $::idxlist {
  410. lappend lens [string length [lindex $strings $i]]
  411. }
  412. do_test $test.3 {
  413. set bytes [list]
  414. set lens [list]
  415. foreach i $idxlist {
  416. lappend bytes [sqlite3_column_bytes $STMT $i]
  417. }
  418. set bytes
  419. } $lens
  420. # bytes16
  421. ifcapable {utf16} {
  422. set lens [list]
  423. foreach i $::idxlist {
  424. lappend lens [expr 2 * [string length [lindex $strings $i]]]
  425. }
  426. do_test $test.4 {
  427. set bytes [list]
  428. set lens [list]
  429. foreach i $idxlist {
  430. lappend bytes [sqlite3_column_bytes16 $STMT $i]
  431. }
  432. set bytes
  433. } $lens
  434. }
  435. # Blob
  436. do_test $test.5 {
  437. set utf8 [list]
  438. foreach i $idxlist {lappend utf8 [sqlite3_column_blob $STMT $i]}
  439. set utf8
  440. } $strings
  441. # UTF-8
  442. do_test $test.6 {
  443. set utf8 [list]
  444. foreach i $idxlist {lappend utf8 [sqlite3_column_text $STMT $i]}
  445. set utf8
  446. } $strings
  447. # Floats
  448. do_test $test.7 {
  449. set utf8 [list]
  450. foreach i $idxlist {lappend utf8 [sqlite3_column_double $STMT $i]}
  451. set utf8
  452. } $doubles
  453. # UTF-16
  454. ifcapable {utf16} {
  455. do_test $test.8 {
  456. set utf8 [list]
  457. foreach i $idxlist {lappend utf8 [utf8 [sqlite3_column_text16 $STMT $i]]}
  458. set utf8
  459. } $strings
  460. }
  461. # Integers
  462. do_test $test.9 {
  463. set ints [list]
  464. foreach i $idxlist {lappend ints [sqlite3_column_int $STMT $i]}
  465. set ints
  466. } $ints
  467. # Floats
  468. do_test $test.10 {
  469. set utf8 [list]
  470. foreach i $idxlist {lappend utf8 [sqlite3_column_double $STMT $i]}
  471. set utf8
  472. } $doubles
  473. # UTF-8
  474. do_test $test.11 {
  475. set utf8 [list]
  476. foreach i $idxlist {lappend utf8 [sqlite3_column_text $STMT $i]}
  477. set utf8
  478. } $strings
  479. # Types
  480. do_test $test.12 {
  481. set types [list]
  482. foreach i $idxlist {lappend types [sqlite3_column_type $STMT $i]}
  483. set types
  484. } $types
  485. # Test that an out of range request returns the equivalent of NULL
  486. do_test $test.13 {
  487. sqlite3_column_int $STMT -1
  488. } {0}
  489. do_test $test.13 {
  490. sqlite3_column_text $STMT -1
  491. } {}
  492. }
  493. ifcapable !floatingpoint {
  494. finish_test
  495. return
  496. }
  497. do_test capi3c-5.0 {
  498. execsql {
  499. CREATE TABLE t1(a VARINT, b BLOB, c VARCHAR(16));
  500. INSERT INTO t1 VALUES(1, 2, 3);
  501. INSERT INTO t1 VALUES('one', 'two', NULL);
  502. INSERT INTO t1 VALUES(1.2, 1.3, 1.4);
  503. }
  504. set sql "SELECT * FROM t1"
  505. set STMT [sqlite3_prepare_v2 $DB $sql -1 TAIL]
  506. sqlite3_column_count $STMT
  507. } 3
  508. check_header $STMT capi3c-5.1 {a b c} {VARINT BLOB VARCHAR(16)}
  509. check_origin_header $STMT capi3c-5.1 {main main main} {t1 t1 t1} {a b c}
  510. do_test capi3c-5.2 {
  511. sqlite3_step $STMT
  512. } SQLITE_ROW
  513. check_header $STMT capi3c-5.3 {a b c} {VARINT BLOB VARCHAR(16)}
  514. check_origin_header $STMT capi3c-5.3 {main main main} {t1 t1 t1} {a b c}
  515. check_data $STMT capi3c-5.4 {INTEGER INTEGER TEXT} {1 2 3} {1.0 2.0 3.0} {1 2 3}
  516. do_test capi3c-5.5 {
  517. sqlite3_step $STMT
  518. } SQLITE_ROW
  519. check_header $STMT capi3c-5.6 {a b c} {VARINT BLOB VARCHAR(16)}
  520. check_origin_header $STMT capi3c-5.6 {main main main} {t1 t1 t1} {a b c}
  521. check_data $STMT capi3c-5.7 {TEXT TEXT NULL} {0 0 0} {0.0 0.0 0.0} {one two {}}
  522. do_test capi3c-5.8 {
  523. sqlite3_step $STMT
  524. } SQLITE_ROW
  525. check_header $STMT capi3c-5.9 {a b c} {VARINT BLOB VARCHAR(16)}
  526. check_origin_header $STMT capi3c-5.9 {main main main} {t1 t1 t1} {a b c}
  527. check_data $STMT capi3c-5.10 {FLOAT FLOAT TEXT} {1 1 1} {1.2 1.3 1.4} {1.2 1.3 1.4}
  528. do_test capi3c-5.11 {
  529. sqlite3_step $STMT
  530. } SQLITE_DONE
  531. do_test capi3c-5.12 {
  532. sqlite3_finalize $STMT
  533. } SQLITE_OK
  534. do_test capi3c-5.20 {
  535. set sql "SELECT a, sum(b), max(c) FROM t1 GROUP BY a"
  536. set STMT [sqlite3_prepare_v2 $DB $sql -1 TAIL]
  537. sqlite3_column_count $STMT
  538. } 3
  539. check_header $STMT capi3c-5.21 {a sum(b) max(c)} {VARINT {} {}}
  540. check_origin_header $STMT capi3c-5.22 {main {} {}} {t1 {} {}} {a {} {}}
  541. do_test capi3c-5.23 {
  542. sqlite3_finalize $STMT
  543. } SQLITE_OK
  544. set ::ENC [execsql {pragma encoding}]
  545. db close
  546. do_test capi3c-6.0 {
  547. sqlite3 db test.db
  548. set DB [sqlite3_connection_pointer db]
  549. if {[sqlite3 -has-codec]==0} { sqlite3_key $DB xyzzy }
  550. set sql {SELECT a FROM t1 order by rowid}
  551. set STMT [sqlite3_prepare_v2 $DB $sql -1 TAIL]
  552. expr 0
  553. } {0}
  554. do_test capi3c-6.1 {
  555. db cache flush
  556. sqlite3_close $DB
  557. } {SQLITE_BUSY}
  558. do_test capi3c-6.2 {
  559. sqlite3_step $STMT
  560. } {SQLITE_ROW}
  561. check_data $STMT capi3c-6.3 {INTEGER} {1} {1.0} {1}
  562. do_test capi3c-6.3 {
  563. sqlite3_finalize $STMT
  564. } {SQLITE_OK}
  565. do_test capi3c-6.4 {
  566. db cache flush
  567. sqlite3_close $DB
  568. } {SQLITE_OK}
  569. do_test capi3c-6.99-misuse {
  570. db close
  571. } {}
  572. # This procedure sets the value of the file-format in file 'test.db'
  573. # to $newval. Also, the schema cookie is incremented.
  574. #
  575. proc set_file_format {newval} {
  576. hexio_write test.db 44 [hexio_render_int32 $newval]
  577. set schemacookie [hexio_get_int [hexio_read test.db 40 4]]
  578. incr schemacookie
  579. hexio_write test.db 40 [hexio_render_int32 $schemacookie]
  580. return {}
  581. }
  582. # This procedure returns the value of the file-format in file 'test.db'.
  583. #
  584. proc get_file_format {{fname test.db}} {
  585. return [hexio_get_int [hexio_read $fname 44 4]]
  586. }
  587. if {![sqlite3 -has-codec]} {
  588. # Test what happens when the library encounters a newer file format.
  589. do_test capi3c-7.1 {
  590. set_file_format 5
  591. } {}
  592. do_test capi3c-7.2 {
  593. catch { sqlite3 db test.db }
  594. catchsql {
  595. SELECT * FROM sqlite_master;
  596. }
  597. } {1 {unsupported file format}}
  598. db close
  599. }
  600. if {![sqlite3 -has-codec]} {
  601. # Now test that the library correctly handles bogus entries in the
  602. # sqlite_master table (schema corruption).
  603. do_test capi3c-8.1 {
  604. forcedelete test.db test.db-journal
  605. sqlite3 db test.db
  606. execsql {
  607. CREATE TABLE t1(a);
  608. }
  609. db close
  610. } {}
  611. do_test capi3c-8.2 {
  612. sqlite3 db test.db
  613. execsql {
  614. PRAGMA writable_schema=ON;
  615. INSERT INTO sqlite_master VALUES(NULL,NULL,NULL,NULL,NULL);
  616. }
  617. db close
  618. } {}
  619. do_test capi3c-8.3 {
  620. catch { sqlite3 db test.db }
  621. catchsql {
  622. SELECT * FROM sqlite_master;
  623. }
  624. } {1 {malformed database schema (?)}}
  625. do_test capi3c-8.4 {
  626. # Build a 5-field row record. The first field is a string 'table', and
  627. # subsequent fields are all NULL.
  628. db close
  629. forcedelete test.db test.db-journal
  630. sqlite3 db test.db
  631. execsql {
  632. CREATE TABLE t1(a);
  633. PRAGMA writable_schema=ON;
  634. INSERT INTO sqlite_master VALUES('table',NULL,NULL,NULL,NULL);
  635. }
  636. db close
  637. } {};
  638. do_test capi3c-8.5 {
  639. catch { sqlite3 db test.db }
  640. catchsql {
  641. SELECT * FROM sqlite_master;
  642. }
  643. } {1 {malformed database schema (?)}}
  644. db close
  645. }
  646. forcedelete test.db
  647. forcedelete test.db-journal
  648. # Test the english language string equivalents for sqlite error codes
  649. set code2english [list \
  650. SQLITE_OK {not an error} \
  651. SQLITE_ERROR {SQL logic error or missing database} \
  652. SQLITE_PERM {access permission denied} \
  653. SQLITE_ABORT {callback requested query abort} \
  654. SQLITE_BUSY {database is locked} \
  655. SQLITE_LOCKED {database table is locked} \
  656. SQLITE_NOMEM {out of memory} \
  657. SQLITE_READONLY {attempt to write a readonly database} \
  658. SQLITE_INTERRUPT {interrupted} \
  659. SQLITE_IOERR {disk I/O error} \
  660. SQLITE_CORRUPT {database disk image is malformed} \
  661. SQLITE_FULL {database or disk is full} \
  662. SQLITE_CANTOPEN {unable to open database file} \
  663. SQLITE_EMPTY {table contains no data} \
  664. SQLITE_SCHEMA {database schema has changed} \
  665. SQLITE_CONSTRAINT {constraint failed} \
  666. SQLITE_MISMATCH {datatype mismatch} \
  667. SQLITE_MISUSE {library routine called out of sequence} \
  668. SQLITE_NOLFS {large file support is disabled} \
  669. SQLITE_AUTH {authorization denied} \
  670. SQLITE_FORMAT {auxiliary database format error} \
  671. SQLITE_RANGE {bind or column index out of range} \
  672. SQLITE_NOTADB {file is encrypted or is not a database} \
  673. unknownerror {unknown error} \
  674. ]
  675. set test_number 1
  676. foreach {code english} $code2english {
  677. do_test capi3c-9.$test_number "sqlite3_test_errstr $code" $english
  678. incr test_number
  679. }
  680. # Test the error message when a "real" out of memory occurs.
  681. if { [permutation] != "nofaultsim" } {
  682. ifcapable memdebug {
  683. do_test capi3c-10-1 {
  684. sqlite3 db test.db
  685. set DB [sqlite3_connection_pointer db]
  686. sqlite3_memdebug_fail 0
  687. catchsql {
  688. select * from sqlite_master;
  689. }
  690. } {1 {out of memory}}
  691. do_test capi3c-10-2 {
  692. sqlite3_errmsg $::DB
  693. } {out of memory}
  694. ifcapable {utf16} {
  695. do_test capi3c-10-3 {
  696. utf8 [sqlite3_errmsg16 $::DB]
  697. } {out of memory}
  698. }
  699. db close
  700. sqlite3_memdebug_fail -1
  701. }
  702. }
  703. # The following tests - capi3c-11.* - test that a COMMIT or ROLLBACK
  704. # statement issued while there are still outstanding VMs that are part of
  705. # the transaction fails.
  706. sqlite3 db test.db
  707. set DB [sqlite3_connection_pointer db]
  708. sqlite_register_test_function $DB func
  709. do_test capi3c-11.1 {
  710. execsql {
  711. BEGIN;
  712. CREATE TABLE t1(a, b);
  713. INSERT INTO t1 VALUES(1, 'int');
  714. INSERT INTO t1 VALUES(2, 'notatype');
  715. }
  716. } {}
  717. do_test capi3c-11.1.1 {
  718. sqlite3_get_autocommit $DB
  719. } 0
  720. do_test capi3c-11.2 {
  721. set STMT [sqlite3_prepare_v2 $DB "SELECT func(b, a) FROM t1" -1 TAIL]
  722. sqlite3_step $STMT
  723. } {SQLITE_ROW}
  724. # As of 3.6.5 a COMMIT is OK during while a query is still running -
  725. # as long as it is a read-only query and not an incremental BLOB write.
  726. #
  727. do_test capi3-11.3.1 {
  728. catchsql {
  729. COMMIT;
  730. }
  731. } {0 {}}
  732. do_test capi3-11.3.2 {
  733. sqlite3_extended_errcode $DB
  734. } {SQLITE_OK}
  735. do_test capi3-11.3.3 {
  736. sqlite3_get_autocommit $DB
  737. } 1
  738. do_test capi3-11.3.4 {
  739. db eval {PRAGMA lock_status}
  740. } {main shared temp closed}
  741. do_test capi3c-11.4 {
  742. sqlite3_step $STMT
  743. } {SQLITE_ERROR}
  744. do_test capi3c-11.5 {
  745. sqlite3_finalize $STMT
  746. } {SQLITE_ERROR}
  747. do_test capi3c-11.6 {
  748. catchsql {
  749. SELECT * FROM t1;
  750. }
  751. } {0 {1 int 2 notatype}}
  752. do_test capi3c-11.7 {
  753. sqlite3_get_autocommit $DB
  754. } 1
  755. do_test capi3c-11.8 {
  756. execsql {
  757. CREATE TABLE t2(a);
  758. INSERT INTO t2 VALUES(1);
  759. INSERT INTO t2 VALUES(2);
  760. BEGIN;
  761. INSERT INTO t2 VALUES(3);
  762. }
  763. } {}
  764. do_test capi3c-11.8.1 {
  765. sqlite3_get_autocommit $DB
  766. } 0
  767. do_test capi3c-11.9 {
  768. set STMT [sqlite3_prepare_v2 $DB "SELECT a FROM t2" -1 TAIL]
  769. sqlite3_step $STMT
  770. } {SQLITE_ROW}
  771. do_test capi3c-11.9.1 {
  772. sqlite3_get_autocommit $DB
  773. } 0
  774. do_test capi3c-11.9.2 {
  775. catchsql {
  776. ROLLBACK;
  777. }
  778. } {0 {}}
  779. do_test capi3c-11.9.3 {
  780. sqlite3_get_autocommit $DB
  781. } 1
  782. do_test capi3c-11.10 {
  783. sqlite3_step $STMT
  784. } {SQLITE_ABORT}
  785. ifcapable !autoreset {
  786. # If SQLITE_OMIT_AUTORESET is defined, then the statement must be
  787. # reset() before it can be passed to step() again.
  788. do_test capi3-11.11a { sqlite3_step $STMT } {SQLITE_MISUSE}
  789. do_test capi3-11.11b { sqlite3_reset $STMT } {SQLITE_ABORT}
  790. }
  791. do_test capi3c-11.11 {
  792. sqlite3_step $STMT
  793. } {SQLITE_ROW}
  794. do_test capi3c-11.12 {
  795. sqlite3_step $STMT
  796. sqlite3_step $STMT
  797. } {SQLITE_DONE}
  798. do_test capi3c-11.13 {
  799. sqlite3_finalize $STMT
  800. } {SQLITE_OK}
  801. do_test capi3c-11.14 {
  802. execsql {
  803. SELECT a FROM t2;
  804. }
  805. } {1 2}
  806. do_test capi3c-11.14.1 {
  807. sqlite3_get_autocommit $DB
  808. } 1
  809. do_test capi3c-11.15 {
  810. catchsql {
  811. ROLLBACK;
  812. }
  813. } {1 {cannot rollback - no transaction is active}}
  814. do_test capi3c-11.15.1 {
  815. sqlite3_get_autocommit $DB
  816. } 1
  817. do_test capi3c-11.16 {
  818. execsql {
  819. SELECT a FROM t2;
  820. }
  821. } {1 2}
  822. # Sanity check on the definition of 'outstanding VM'. This means any VM
  823. # that has had sqlite3_step() called more recently than sqlite3_finalize() or
  824. # sqlite3_reset(). So a VM that has just been prepared or reset does not
  825. # count as an active VM.
  826. do_test capi3c-11.17 {
  827. execsql {
  828. BEGIN;
  829. }
  830. } {}
  831. do_test capi3c-11.18 {
  832. set STMT [sqlite3_prepare_v2 $DB "SELECT a FROM t1" -1 TAIL]
  833. catchsql {
  834. COMMIT;
  835. }
  836. } {0 {}}
  837. do_test capi3c-11.19 {
  838. sqlite3_step $STMT
  839. } {SQLITE_ROW}
  840. do_test capi3c-11.20 {
  841. catchsql {
  842. BEGIN;
  843. COMMIT;
  844. }
  845. } {0 {}}
  846. do_test capi3c-11.20 {
  847. sqlite3_reset $STMT
  848. catchsql {
  849. COMMIT;
  850. }
  851. } {1 {cannot commit - no transaction is active}}
  852. do_test capi3c-11.21 {
  853. sqlite3_finalize $STMT
  854. } {SQLITE_OK}
  855. # The following tests - capi3c-12.* - check that its Ok to start a
  856. # transaction while other VMs are active, and that its Ok to execute
  857. # atomic updates in the same situation
  858. #
  859. do_test capi3c-12.1 {
  860. set STMT [sqlite3_prepare_v2 $DB "SELECT a FROM t2" -1 TAIL]
  861. sqlite3_step $STMT
  862. } {SQLITE_ROW}
  863. do_test capi3c-12.2 {
  864. catchsql {
  865. INSERT INTO t1 VALUES(3, NULL);
  866. }
  867. } {0 {}}
  868. do_test capi3c-12.3 {
  869. catchsql {
  870. INSERT INTO t2 VALUES(4);
  871. }
  872. } {0 {}}
  873. do_test capi3c-12.4 {
  874. catchsql {
  875. BEGIN;
  876. INSERT INTO t1 VALUES(4, NULL);
  877. }
  878. } {0 {}}
  879. do_test capi3c-12.5 {
  880. sqlite3_step $STMT
  881. } {SQLITE_ROW}
  882. do_test capi3c-12.5.1 {
  883. sqlite3_step $STMT
  884. } {SQLITE_ROW}
  885. do_test capi3c-12.6 {
  886. sqlite3_step $STMT
  887. } {SQLITE_DONE}
  888. do_test capi3c-12.7 {
  889. sqlite3_finalize $STMT
  890. } {SQLITE_OK}
  891. do_test capi3c-12.8 {
  892. execsql {
  893. COMMIT;
  894. SELECT a FROM t1;
  895. }
  896. } {1 2 3 4}
  897. # Test cases capi3c-13.* test the sqlite3_clear_bindings() and
  898. # sqlite3_sleep APIs.
  899. #
  900. if {[llength [info commands sqlite3_clear_bindings]]>0} {
  901. do_test capi3c-13.1 {
  902. execsql {
  903. DELETE FROM t1;
  904. }
  905. set STMT [sqlite3_prepare_v2 $DB "INSERT INTO t1 VALUES(?, ?)" -1 TAIL]
  906. sqlite3_step $STMT
  907. } {SQLITE_DONE}
  908. do_test capi3c-13.2 {
  909. sqlite3_reset $STMT
  910. sqlite3_bind_text $STMT 1 hello 5
  911. sqlite3_bind_text $STMT 2 world 5
  912. sqlite3_step $STMT
  913. } {SQLITE_DONE}
  914. do_test capi3c-13.3 {
  915. sqlite3_reset $STMT
  916. sqlite3_clear_bindings $STMT
  917. sqlite3_step $STMT
  918. } {SQLITE_DONE}
  919. do_test capi3c-13-4 {
  920. sqlite3_finalize $STMT
  921. execsql {
  922. SELECT * FROM t1;
  923. }
  924. } {{} {} hello world {} {}}
  925. }
  926. if {[llength [info commands sqlite3_sleep]]>0} {
  927. do_test capi3c-13-5 {
  928. set ms [sqlite3_sleep 80]
  929. expr {$ms==80 || $ms==1000}
  930. } {1}
  931. }
  932. # Ticket #1219: Make sure binding APIs can handle a NULL pointer.
  933. #
  934. do_test capi3c-14.1 {
  935. set rc [catch {sqlite3_bind_text 0 1 hello 5} msg]
  936. lappend rc $msg
  937. } {1 SQLITE_MISUSE}
  938. # Ticket #1650: Honor the nBytes parameter to sqlite3_prepare.
  939. #
  940. do_test capi3c-15.1 {
  941. set sql {SELECT * FROM t2}
  942. set nbytes [string length $sql]
  943. append sql { WHERE a==1}
  944. set STMT [sqlite3_prepare_v2 $DB $sql $nbytes TAIL]
  945. sqlite3_step $STMT
  946. sqlite3_column_int $STMT 0
  947. } {1}
  948. do_test capi3c-15.2 {
  949. sqlite3_step $STMT
  950. sqlite3_column_int $STMT 0
  951. } {2}
  952. do_test capi3c-15.3 {
  953. sqlite3_finalize $STMT
  954. } {SQLITE_OK}
  955. # Make sure code is always generated even if an IF EXISTS or
  956. # IF NOT EXISTS clause is present that the table does not or
  957. # does exists. That way we will always have a prepared statement
  958. # to expire when the schema changes.
  959. #
  960. do_test capi3c-16.1 {
  961. set sql {DROP TABLE IF EXISTS t3}
  962. set STMT [sqlite3_prepare_v2 $DB $sql -1 TAIL]
  963. sqlite3_finalize $STMT
  964. expr {$STMT!=""}
  965. } {1}
  966. do_test capi3c-16.2 {
  967. set sql {CREATE TABLE IF NOT EXISTS t1(x,y)}
  968. set STMT [sqlite3_prepare_v2 $DB $sql -1 TAIL]
  969. sqlite3_finalize $STMT
  970. expr {$STMT!=""}
  971. } {1}
  972. # But still we do not generate code if there is no SQL
  973. #
  974. do_test capi3c-16.3 {
  975. set STMT [sqlite3_prepare_v2 $DB {} -1 TAIL]
  976. sqlite3_finalize $STMT
  977. expr {$STMT==""}
  978. } {1}
  979. do_test capi3c-16.4 {
  980. set STMT [sqlite3_prepare_v2 $DB {;} -1 TAIL]
  981. sqlite3_finalize $STMT
  982. expr {$STMT==""}
  983. } {1}
  984. # Ticket #2154.
  985. #
  986. do_test capi3c-17.1 {
  987. set STMT [sqlite3_prepare_v2 $DB {SELECT max(a) FROM t2} -1 TAIL]
  988. sqlite3_step $STMT
  989. } SQLITE_ROW
  990. do_test capi3c-17.2 {
  991. sqlite3_column_int $STMT 0
  992. } 4
  993. do_test capi3c-17.3 {
  994. sqlite3_step $STMT
  995. } SQLITE_DONE
  996. do_test capi3c-17.4 {
  997. sqlite3_reset $STMT
  998. db eval {CREATE INDEX i2 ON t2(a)}
  999. sqlite3_step $STMT
  1000. } SQLITE_ROW
  1001. do_test capi3c-17.5 {
  1002. sqlite3_column_int $STMT 0
  1003. } 4
  1004. do_test capi3c-17.6 {
  1005. sqlite3_step $STMT
  1006. } SQLITE_DONE
  1007. do_test capi3c-17.7 {
  1008. sqlite3_reset $STMT
  1009. db eval {DROP INDEX i2}
  1010. sqlite3_step $STMT
  1011. } SQLITE_ROW
  1012. do_test capi3c-17.8 {
  1013. sqlite3_column_int $STMT 0
  1014. } 4
  1015. do_test capi3c-17.9 {
  1016. sqlite3_step $STMT
  1017. } SQLITE_DONE
  1018. do_test capi3c-17.10 {
  1019. sqlite3_finalize $STMT
  1020. set STMT [sqlite3_prepare_v2 $DB {SELECT b FROM t1 WHERE a=?} -1 TAIL]
  1021. sqlite3_bind_int $STMT 1 2
  1022. db eval {
  1023. DELETE FROM t1;
  1024. INSERT INTO t1 VALUES(1,'one');
  1025. INSERT INTO t1 VALUES(2,'two');
  1026. INSERT INTO t1 VALUES(3,'three');
  1027. INSERT INTO t1 VALUES(4,'four');
  1028. }
  1029. sqlite3_step $STMT
  1030. } SQLITE_ROW
  1031. do_test capi3c-17.11 {
  1032. sqlite3_column_text $STMT 0
  1033. } two
  1034. do_test capi3c-17.12 {
  1035. sqlite3_step $STMT
  1036. } SQLITE_DONE
  1037. do_test capi3c-17.13 {
  1038. sqlite3_reset $STMT
  1039. db eval {CREATE INDEX i1 ON t1(a)}
  1040. sqlite3_step $STMT
  1041. } SQLITE_ROW
  1042. do_test capi3c-17.14 {
  1043. sqlite3_column_text $STMT 0
  1044. } two
  1045. do_test capi3c-17.15 {
  1046. sqlite3_step $STMT
  1047. } SQLITE_DONE
  1048. do_test capi3c-17.16 {
  1049. sqlite3_reset $STMT
  1050. db eval {DROP INDEX i1}
  1051. sqlite3_step $STMT
  1052. } SQLITE_ROW
  1053. do_test capi3c-17.17 {
  1054. sqlite3_column_text $STMT 0
  1055. } two
  1056. do_test capi3c-17.18 {
  1057. sqlite3_step $STMT
  1058. } SQLITE_DONE
  1059. do_test capi3c-17.99 {
  1060. sqlite3_finalize $STMT
  1061. } SQLITE_OK
  1062. # On the mailing list it has been reported that finalizing after
  1063. # an SQLITE_BUSY return leads to a segfault. Here we test that case.
  1064. #
  1065. do_test capi3c-18.1 {
  1066. sqlite3 db2 test.db
  1067. set STMT [sqlite3_prepare_v2 $DB {SELECT max(a) FROM t1} -1 TAIL]
  1068. sqlite3_step $STMT
  1069. } SQLITE_ROW
  1070. do_test capi3c-18.2 {
  1071. sqlite3_column_int $STMT 0
  1072. } 4
  1073. do_test capi3c-18.3 {
  1074. sqlite3_reset $STMT
  1075. db2 eval {BEGIN EXCLUSIVE}
  1076. sqlite3_step $STMT
  1077. } SQLITE_BUSY
  1078. do_test capi3c-18.4 {
  1079. sqlite3_finalize $STMT
  1080. } SQLITE_BUSY
  1081. do_test capi3c-18.5 {
  1082. db2 eval {COMMIT}
  1083. db2 close
  1084. } {}
  1085. # Ticket #2158. The sqlite3_step() will still return SQLITE_SCHEMA
  1086. # if the database schema changes in a way that makes the statement
  1087. # no longer valid.
  1088. #
  1089. do_test capi3c-19.1 {
  1090. db eval {
  1091. CREATE TABLE t3(x,y);
  1092. INSERT INTO t3 VALUES(1,2);
  1093. }
  1094. set STMT [sqlite3_prepare_v2 $DB {SELECT * FROM t3} -1 TAIL]
  1095. sqlite3_step $STMT
  1096. } SQLITE_ROW
  1097. do_test capi3c-19.2 {
  1098. sqlite3_column_int $STMT 0
  1099. } 1
  1100. do_test capi3c-19.3 {
  1101. sqlite3_step $STMT
  1102. } SQLITE_DONE
  1103. do_test capi3c-19.4 {
  1104. sqlite3_reset $STMT
  1105. db eval {DROP TABLE t3}
  1106. sqlite3_step $STMT
  1107. } SQLITE_ERROR
  1108. do_test capi3c-19.4.1 {
  1109. sqlite3_errmsg $DB
  1110. } {no such table: t3}
  1111. ifcapable deprecated {
  1112. do_test capi3c-19.4.2 {
  1113. sqlite3_expired $STMT
  1114. } 1
  1115. }
  1116. do_test capi3c-19.4.3 {
  1117. sqlite3_errmsg $DB
  1118. } {no such table: t3}
  1119. ifcapable deprecated {
  1120. do_test capi3c-19.4.4 {
  1121. sqlite3_expired 0
  1122. } 1
  1123. }
  1124. do_test capi3c-19.5 {
  1125. sqlite3_reset $STMT
  1126. db eval {
  1127. CREATE TABLE t3(x,y);
  1128. INSERT INTO t3 VALUES(1,2);
  1129. }
  1130. sqlite3_step $STMT
  1131. } SQLITE_ROW
  1132. ifcapable deprecated {
  1133. do_test capi3c-19.5.2 {
  1134. sqlite3_expired $STMT
  1135. } 0
  1136. }
  1137. do_test capi3c-19.6 {
  1138. sqlite3_column_int $STMT 1
  1139. } 2
  1140. do_test capi3c-19.99 {
  1141. sqlite3_finalize $STMT
  1142. } SQLITE_OK
  1143. # Make sure a change in a separate database connection does not
  1144. # cause an SQLITE_SCHEMA return.
  1145. #
  1146. do_test capi3c-20.1 {
  1147. set STMT [sqlite3_prepare_v2 $DB {SELECT * FROM t3} -1 TAIL]
  1148. sqlite3 db2 test.db
  1149. db2 eval {CREATE TABLE t4(x)}
  1150. sqlite3_step $STMT
  1151. } SQLITE_ROW
  1152. do_test capi3c-20.2 {
  1153. sqlite3_column_int $STMT 1
  1154. } 2
  1155. do_test capi3c-20.3 {
  1156. sqlite3_step $STMT
  1157. } SQLITE_DONE
  1158. do_test capi3c-20.4 {
  1159. db2 close
  1160. sqlite3_finalize $STMT
  1161. } SQLITE_OK
  1162. # Test that sqlite3_step() sets the database error code correctly.
  1163. # See ticket #2497.
  1164. #
  1165. ifcapable progress {
  1166. do_test capi3c-21.1 {
  1167. set STMT [sqlite3_prepare_v2 $DB {SELECT * FROM t3} -1 TAIL]
  1168. db progress 5 "expr 1"
  1169. sqlite3_step $STMT
  1170. } {SQLITE_INTERRUPT}
  1171. do_test capi3c-21.2 {
  1172. sqlite3_extended_errcode $DB
  1173. } {SQLITE_INTERRUPT}
  1174. do_test capi3c-21.3 {
  1175. sqlite3_finalize $STMT
  1176. } {SQLITE_INTERRUPT}
  1177. do_test capi3c-21.4 {
  1178. set STMT [sqlite3_prepare $DB {SELECT * FROM t3} -1 TAIL]
  1179. db progress 5 "expr 1"
  1180. sqlite3_step $STMT
  1181. } {SQLITE_ERROR}
  1182. do_test capi3c-21.5 {
  1183. sqlite3_errcode $DB
  1184. } {SQLITE_ERROR}
  1185. do_test capi3c-21.6 {
  1186. sqlite3_finalize $STMT
  1187. } {SQLITE_INTERRUPT}
  1188. do_test capi3c-21.7 {
  1189. sqlite3_errcode $DB
  1190. } {SQLITE_INTERRUPT}
  1191. do_test capi3c-21.8 {
  1192. sqlite3_extended_errcode $DB
  1193. } {SQLITE_INTERRUPT}
  1194. }
  1195. # Make sure sqlite3_result_error_code() returns the correct error code.
  1196. # See ticket #2940
  1197. #
  1198. do_test capi3c-22.1 {
  1199. db progress 0 {}
  1200. set STMT [sqlite3_prepare_v2 db {SELECT test_error('the message',3)} -1 TAIL]
  1201. sqlite3_step $STMT
  1202. } {SQLITE_PERM}
  1203. sqlite3_finalize $STMT
  1204. do_test capi3c-22.2 {
  1205. set STMT [sqlite3_prepare_v2 db {SELECT test_error('the message',4)} -1 TAIL]
  1206. sqlite3_step $STMT
  1207. } {SQLITE_ABORT}
  1208. sqlite3_finalize $STMT
  1209. do_test capi3c-22.3 {
  1210. set STMT [sqlite3_prepare_v2 db {SELECT test_error('the message',16)} -1 TAIL]
  1211. sqlite3_step $STMT
  1212. } {SQLITE_EMPTY}
  1213. sqlite3_finalize $STMT
  1214. # For a multi-column result set where the same table column is repeated
  1215. # in multiple columns of the output, verify that doing a UTF-8 to UTF-16
  1216. # conversion (or vice versa) on one column does not change the value of
  1217. # the second.
  1218. #
  1219. ifcapable utf16 {
  1220. do_test capi3c-23.1 {
  1221. set STMT [sqlite3_prepare_v2 db {SELECT b,b,b,b FROM t1} -1 TAIL]
  1222. sqlite3_step $STMT
  1223. } {SQLITE_ROW}
  1224. do_test capi3c-23.2 {
  1225. sqlite3_column_text16 $STMT 0
  1226. sqlite3_column_text $STMT 1
  1227. } {one}
  1228. do_test capi3c-23.3 {
  1229. sqlite3_column_text16 $STMT 2
  1230. sqlite3_column_text $STMT 3
  1231. } {one}
  1232. sqlite3_finalize $STMT
  1233. do_test capi3c-23.4 {
  1234. set STMT [sqlite3_prepare_v2 db {SELECT b||'x',b,b,b FROM t1} -1 TAIL]
  1235. sqlite3_step $STMT
  1236. } {SQLITE_ROW}
  1237. do_test capi3c-23.5 {
  1238. sqlite3_column_text16 $STMT 0
  1239. sqlite3_column_text $STMT 1
  1240. } {one}
  1241. do_test capi3c-23.6 {
  1242. sqlite3_column_text16 $STMT 2
  1243. sqlite3_column_text $STMT 3
  1244. } {one}
  1245. sqlite3_finalize $STMT
  1246. }
  1247. # Test decltype on some SELECT statements that contain sub-selects.
  1248. #
  1249. proc decltype {zSql} {
  1250. set ret [list]
  1251. set STMT [sqlite3_prepare_v2 db $zSql -1 TAIL]
  1252. for {set i 0} {$i < [sqlite3_column_count $STMT]} {incr i} {
  1253. lappend ret [sqlite3_column_decltype $STMT $i]
  1254. }
  1255. sqlite3_finalize $STMT
  1256. return $ret
  1257. }
  1258. do_test capi3c-24.1 {
  1259. execsql { CREATE TABLE t5(a INTEGER, b STRING, c DATETIME) }
  1260. decltype {SELECT * FROM t5}
  1261. } {INTEGER STRING DATETIME}
  1262. do_test capi3c-24.2 {
  1263. decltype {SELECT (SELECT c) FROM t5}
  1264. } {DATETIME}
  1265. do_test capi3c-24.3 {
  1266. decltype {SELECT (SELECT * FROM (SELECT c)) FROM t5}
  1267. } {DATETIME}
  1268. do_test capi3c-24.4 {
  1269. decltype {SELECT * FROM (SELECT * FROM t5 ORDER BY c LIMIT 1) ORDER BY b}
  1270. } {INTEGER STRING DATETIME}
  1271. do_test capi3c-24.5 {
  1272. decltype {
  1273. SELECT (SELECT x FROM (SELECT c AS x))
  1274. FROM (SELECT * FROM t5 ORDER BY c LIMIT 1) ORDER BY b
  1275. }
  1276. } {DATETIME}
  1277. do_test capi3c-24.3 {
  1278. decltype {SELECT (SELECT x FROM (SELECT t5.a AS x)) FROM t5}
  1279. } {INTEGER}
  1280. finish_test