1# 2011 May 06 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# 12 13set testdir [file dirname $argv0] 14source $testdir/tester.tcl 15set testprefix e_uri 16do_not_use_codec 17db close 18 19proc parse_uri {uri} { 20 testvfs tvfs2 21 testvfs tvfs 22 tvfs filter xOpen 23 tvfs script parse_uri_open_cb 24 25 set ::uri_open [list] 26 set DB [sqlite3_open_v2 $uri { 27 SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_WAL 28 } tvfs] 29 set fileName [sqlite3_db_filename $DB main] 30 sqlite3_close $DB 31 forcedelete $fileName 32 tvfs delete 33 tvfs2 delete 34 35 set ::uri_open 36} 37proc parse_uri_open_cb {method file arglist} { 38 set ::uri_open [list $file $arglist] 39} 40 41proc open_uri_error {uri} { 42 set flags {SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_WAL} 43 set DB [sqlite3_open_v2 $uri $flags ""] 44 set e [sqlite3_errmsg $DB] 45 sqlite3_close $DB 46 set e 47} 48 49# EVIDENCE-OF: R-35840-33204 If URI filename interpretation is enabled, 50# and the filename argument begins with "file:", then the filename is 51# interpreted as a URI. 52# 53# EVIDENCE-OF: R-27632-24205 URI filename interpretation is enabled if 54# the SQLITE_OPEN_URI flag is set in the third argument to 55# sqlite3_open_v2(), or if it has been enabled globally using the 56# SQLITE_CONFIG_URI option with the sqlite3_config() method or by the 57# SQLITE_USE_URI compile-time option. 58# 59if {$tcl_platform(platform) == "unix"} { 60 set flags [list SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE] 61 62 # Tests with SQLITE_CONFIG_URI configured to false. URI intepretation is 63 # only enabled if the SQLITE_OPEN_URI flag is specified. 64 sqlite3_shutdown 65 sqlite3_config_uri 0 66 do_test 1.1 { 67 forcedelete file:test.db test.db 68 set DB [sqlite3_open_v2 file:test.db [concat $flags SQLITE_OPEN_URI] ""] 69 list [file exists file:test.db] [file exists test.db] 70 } {0 1} 71 do_test 1.2 { 72 forcedelete file:test.db2 test.db2 73 set STMT [sqlite3_prepare $DB "ATTACH 'file:test.db2' AS aux" -1 dummy] 74 sqlite3_step $STMT 75 sqlite3_finalize $STMT 76 list [file exists file:test.db2] [file exists test.db2] 77 } {0 1} 78 sqlite3_close $DB 79 do_test 1.3 { 80 forcedelete file:test.db test.db 81 set DB [sqlite3_open_v2 file:test.db [concat $flags] ""] 82 list [file exists file:test.db] [file exists test.db] 83 } {1 0} 84 do_test 1.4 { 85 forcedelete file:test.db2 test.db2 86 set STMT [sqlite3_prepare $DB "ATTACH 'file:test.db2' AS aux" -1 dummy] 87 sqlite3_step $STMT 88 sqlite3_finalize $STMT 89 list [file exists file:test.db2] [file exists test.db2] 90 } {1 0} 91 sqlite3_close $DB 92 93 # Tests with SQLITE_CONFIG_URI configured to true. URI intepretation is 94 # enabled with or without SQLITE_OPEN_URI. 95 # 96 sqlite3_shutdown 97 sqlite3_config_uri 1 98 do_test 1.5 { 99 forcedelete file:test.db test.db 100 set DB [sqlite3_open_v2 file:test.db [concat $flags SQLITE_OPEN_URI] ""] 101 list [file exists file:test.db] [file exists test.db] 102 } {0 1} 103 do_test 1.6 { 104 forcedelete file:test.db2 test.db2 105 set STMT [sqlite3_prepare $DB "ATTACH 'file:test.db2' AS aux" -1 dummy] 106 sqlite3_step $STMT 107 sqlite3_finalize $STMT 108 list [file exists file:test.db2] [file exists test.db2] 109 } {0 1} 110 sqlite3_close $DB 111 do_test 1.7 { 112 forcedelete file:test.db test.db 113 set DB [sqlite3_open_v2 file:test.db [concat $flags] ""] 114 list [file exists file:test.db] [file exists test.db] 115 } {0 1} 116 do_test 1.8 { 117 forcedelete file:test.db2 test.db2 118 set STMT [sqlite3_prepare $DB "ATTACH 'file:test.db2' AS aux" -1 dummy] 119 sqlite3_step $STMT 120 sqlite3_finalize $STMT 121 list [file exists file:test.db2] [file exists test.db2] 122 } {0 1} 123 sqlite3_close $DB 124} 125 126# ensure uri processing enabled for the rest of the tests 127sqlite3_shutdown 128sqlite3_config_uri 1 129 130# EVIDENCE-OF: R-06842-00595 If the URI contains an authority, then it 131# must be either an empty string or the string "localhost". 132# 133# EVIDENCE-OF: R-17482-00398 If the authority is not an empty string or 134# "localhost", an error is returned to the caller. 135# 136if {$tcl_platform(platform) == "unix"} { 137 set flags [list SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_URI] 138 foreach {tn uri error} " 139 1 {file://localhost[test_pwd /]test.db} {not an error} 140 2 {file://[test_pwd /]test.db} {not an error} 141 3 {file://x[test_pwd /]test.db} {invalid uri authority: x} 142 4 {file://invalid[test_pwd /]test.db} {invalid uri authority: invalid} 143 " { 144 do_test 2.$tn { 145 set DB [sqlite3_open_v2 $uri $flags ""] 146 set e [sqlite3_errmsg $DB] 147 sqlite3_close $DB 148 set e 149 } $error 150 } 151} 152 153# EVIDENCE-OF: R-45981-25528 The fragment component of a URI, if 154# present, is ignored. 155# 156# It is difficult to test that something is ignored correctly. So these tests 157# just show that adding a fragment does not interfere with the pathname or 158# parameters passed through to the VFS xOpen() methods. 159# 160foreach {tn uri parse} " 161 1 {file:test.db#abc} {[test_pwd / {}]test.db {}} 162 2 {file:test.db?a=b#abc} {[test_pwd / {}]test.db {a b}} 163 3 {file:test.db?a=b#?c=d} {[test_pwd / {}]test.db {a b}} 164" { 165 do_filepath_test 3.$tn { parse_uri $uri } $parse 166} 167 168# EVIDENCE-OF: R-62557-09390 SQLite uses the path component of the URI 169# as the name of the disk file which contains the database. 170# 171# EVIDENCE-OF: R-28659-11035 If the path begins with a '/' character, 172# then it is interpreted as an absolute path. 173# 174# EVIDENCE-OF: R-46234-61323 If the path does not begin with a '/' 175# (meaning that the authority section is omitted from the URI) then the 176# path is interpreted as a relative path. 177# 178foreach {tn uri parse} " 179 1 {file:test.db} {[test_pwd / {}]test.db {}} 180 2 {file:/test.db} {/test.db {}} 181 3 {file:///test.db} {/test.db {}} 182 4 {file://localhost/test.db} {/test.db {}} 183 5 {file:/a/b/c/test.db} {/a/b/c/test.db {}} 184" { 185 do_filepath_test 4.$tn { parse_uri $uri } $parse 186} 187 188# EVIDENCE-OF: R-01612-30877 The "vfs" parameter may be used to specify 189# the name of a VFS object that provides the operating system interface 190# that should be used to access the database file on disk. 191# 192# The above is tested by cases 1.* below. 193# 194# EVIDENCE-OF: R-52293-58497 If this option is set to an empty string 195# the default VFS object is used. 196# 197# The above is tested by cases 2.* below. 198# 199# EVIDENCE-OF: R-31855-18665 If sqlite3_open_v2() is used and the vfs 200# option is present, then the VFS specified by the option takes 201# precedence over the value passed as the fourth parameter to 202# sqlite3_open_v2(). 203# 204# The above is tested by cases 3.* below. 205# 206proc vfs_open_cb {name args} { 207 set ::vfs $name 208} 209foreach {name default} {vfs1 0 vfs2 0 vfs3 1} { 210 testvfs $name -default $default 211 $name filter xOpen 212 $name script [list vfs_open_cb $name] 213} 214foreach {tn uri defvfs vfs} { 215 1.1 "file:test.db?vfs=vfs1" "" vfs1 216 1.2 "file:test.db?vfs=vfs2" "" vfs2 217 218 2.1 "file:test.db" vfs1 vfs1 219 2.2 "file:test.db?vfs=" vfs1 vfs3 220 221 3.1 "file:test.db?vfs=vfs1" vfs2 vfs1 222 3.2 "file:test.db?vfs=vfs2" vfs1 vfs2 223 3.3 "file:test.db?xvfs=vfs1" vfs2 vfs2 224 3.4 "file:test.db?xvfs=vfs2" vfs1 vfs1 225} { 226 do_test 5.$tn { 227 set flags [list SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_URI] 228 sqlite3_close [ 229 sqlite3_open_v2 $uri $flags $defvfs 230 ] 231 set ::vfs 232 } $vfs 233} 234vfs1 delete 235vfs2 delete 236vfs3 delete 237 238# EVIDENCE-OF: R-48365-36308 Specifying an unknown VFS is an error. 239# 240set flags [list SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_URI] 241do_test 6.1 { 242 set DB [sqlite3_open_v2 file:test.db?vfs=nosuchvfs $flags ""] 243 set errmsg [sqlite3_errmsg $DB] 244 sqlite3_close $DB 245 set errmsg 246} {no such vfs: nosuchvfs} 247 248 249# EVIDENCE-OF: R-44013-13102 The mode parameter may be set to either 250# "ro", "rw", "rwc", or "memory". Attempting to set it to any other 251# value is an error 252# 253sqlite3 db test.db 254db close 255foreach {tn uri error} " 256 1 {file:test.db?mode=ro} {not an error} 257 2 {file:test.db?mode=rw} {not an error} 258 3 {file:test.db?mode=rwc} {not an error} 259 4 {file:test.db?mode=Ro} {no such access mode: Ro} 260 5 {file:test.db?mode=Rw} {no such access mode: Rw} 261 6 {file:test.db?mode=Rwc} {no such access mode: Rwc} 262 7 {file:test.db?mode=memory} {not an error} 263 8 {file:test.db?mode=MEMORY} {no such access mode: MEMORY} 264" { 265 do_test 7.$tn { open_uri_error $uri } $error 266} 267 268 269# EVIDENCE-OF: R-43036-46756 If "ro" is specified, then the database is 270# opened for read-only access, just as if the SQLITE_OPEN_READONLY flag 271# had been set in the third argument to sqlite3_open_v2(). 272# 273# EVIDENCE-OF: R-40137-26050 If the mode option is set to "rw", then the 274# database is opened for read-write (but not create) access, as if 275# SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had been set. 276# 277# EVIDENCE-OF: R-26845-32976 Value "rwc" is equivalent to setting both 278# SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. 279# 280foreach {tn uri read write create} { 281 1 {file:test.db?mode=ro} 1 0 0 282 2 {file:test.db?mode=rw} 1 1 0 283 3 {file:test.db?mode=rwc} 1 1 1 284} { 285 set RES(c,0) {1 {unable to open database file}} 286 set RES(c,1) {0 {}} 287 set RES(w,0) {1 {attempt to write a readonly database}} 288 set RES(w,1) {0 {}} 289 set RES(r,0) {1 {this never happens}} 290 set RES(r,1) {0 {a b}} 291 292 # Test CREATE access: 293 forcedelete test.db 294 do_test 8.$tn.c { list [catch { sqlite3 db $uri } msg] $msg } $RES(c,$create) 295 catch { db close } 296 297 sqlite3 db test.db 298 db eval { CREATE TABLE t1(a, b) ; INSERT INTO t1 VALUES('a', 'b') ;} 299 db close 300 301 # Test READ access: 302 do_test 8.$tn.r { 303 sqlite3 db $uri 304 catchsql { SELECT * FROM t1 } 305 } $RES(r,$read) 306 307 # Test WRITE access: 308 do_test 8.$tn.w { 309 sqlite3 db $uri 310 catchsql { INSERT INTO t1 VALUES(1, 2) } 311 } $RES(w,$write) 312 313 catch {db close} 314} 315 316# EVIDENCE-OF: R-20590-08726 It is an error to specify a value for the 317# mode parameter that is less restrictive than that specified by the 318# flags passed in the third parameter to sqlite3_open_v2(). 319# 320forcedelete test.db 321sqlite3 db test.db 322db close 323foreach {tn uri flags error} { 324 1 {file:test.db?mode=ro} ro {not an error} 325 2 {file:test.db?mode=ro} rw {not an error} 326 3 {file:test.db?mode=ro} rwc {not an error} 327 328 4 {file:test.db?mode=rw} ro {access mode not allowed: rw} 329 5 {file:test.db?mode=rw} rw {not an error} 330 6 {file:test.db?mode=rw} rwc {not an error} 331 332 7 {file:test.db?mode=rwc} ro {access mode not allowed: rwc} 333 8 {file:test.db?mode=rwc} rw {access mode not allowed: rwc} 334 9 {file:test.db?mode=rwc} rwc {not an error} 335} { 336 set f(ro) [list SQLITE_OPEN_READONLY SQLITE_OPEN_URI] 337 set f(rw) [list SQLITE_OPEN_READWRITE SQLITE_OPEN_URI] 338 set f(rwc) [list SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_URI] 339 340 set DB [sqlite3_open_v2 $uri $f($flags) ""] 341 set e [sqlite3_errmsg $DB] 342 sqlite3_close $DB 343 344 do_test 9.$tn { set e } $error 345} 346 347# EVIDENCE-OF: R-23182-54295 The cache parameter may be set to either 348# "shared" or "private". 349sqlite3 db test.db 350db close 351foreach {tn uri error} " 352 1 {file:test.db?cache=private} {not an error} 353 2 {file:test.db?cache=shared} {not an error} 354 3 {file:test.db?cache=yes} {no such cache mode: yes} 355 4 {file:test.db?cache=} {no such cache mode: } 356" { 357 do_test 10.$tn { open_uri_error $uri } $error 358} 359 360# EVIDENCE-OF: R-23027-03515 Setting it to "shared" is equivalent to 361# setting the SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed 362# to sqlite3_open_v2(). 363# 364# EVIDENCE-OF: R-49793-28525 Setting the cache parameter to "private" is 365# equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit. 366# 367# EVIDENCE-OF: R-31773-41793 If sqlite3_open_v2() is used and the 368# "cache" parameter is present in a URI filename, its value overrides 369# any behavior requested by setting SQLITE_OPEN_PRIVATECACHE or 370# SQLITE_OPEN_SHAREDCACHE flag. 371# 372set orig [sqlite3_enable_shared_cache] 373foreach {tn uri flags shared_default isshared} { 374 1.1 "file:test.db" "" 0 0 375 1.2 "file:test.db" "" 1 1 376 1.3 "file:test.db" private 0 0 377 1.4 "file:test.db" private 1 0 378 1.5 "file:test.db" shared 0 1 379 1.6 "file:test.db" shared 1 1 380 381 2.1 "file:test.db?cache=private" "" 0 0 382 2.2 "file:test.db?cache=private" "" 1 0 383 2.3 "file:test.db?cache=private" private 0 0 384 2.4 "file:test.db?cache=private" private 1 0 385 2.5 "file:test.db?cache=private" shared 0 0 386 2.6 "file:test.db?cache=private" shared 1 0 387 388 3.1 "file:test.db?cache=shared" "" 0 1 389 3.2 "file:test.db?cache=shared" "" 1 1 390 3.3 "file:test.db?cache=shared" private 0 1 391 3.4 "file:test.db?cache=shared" private 1 1 392 3.5 "file:test.db?cache=shared" shared 0 1 393 3.6 "file:test.db?cache=shared" shared 1 1 394} { 395 forcedelete test.db 396 sqlite3_enable_shared_cache 1 397 sqlite3 db test.db 398 sqlite3_enable_shared_cache 0 399 400 db eval { 401 CREATE TABLE t1(x); 402 INSERT INTO t1 VALUES('ok'); 403 } 404 405 unset -nocomplain f 406 set f() {SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_URI} 407 set f(shared) [concat $f() SQLITE_OPEN_SHAREDCACHE] 408 set f(private) [concat $f() SQLITE_OPEN_PRIVATECACHE] 409 410 sqlite3_enable_shared_cache $shared_default 411 set DB [sqlite3_open_v2 $uri $f($flags) ""] 412 413 set STMT [sqlite3_prepare $DB "SELECT * FROM t1" -1 dummy] 414 415 db eval { 416 BEGIN; 417 INSERT INTO t1 VALUES('ko'); 418 } 419 420 sqlite3_step $STMT 421 sqlite3_finalize $STMT 422 423 set RES(0) {not an error} 424 set RES(1) {database table is locked: t1} 425 426 do_test 11.$tn { sqlite3_errmsg $DB } $RES($isshared) 427 428 sqlite3_close $DB 429 db close 430} 431sqlite3_enable_shared_cache $orig 432 433# EVIDENCE-OF: R-63472-46769 Specifying an unknown parameter in the 434# query component of a URI is not an error. 435# 436do_filepath_test 12.1 { 437 parse_uri file://localhost/test.db?an=unknown¶meter=is&ok= 438} {/test.db {an unknown parameter is ok {}}} 439do_filepath_test 12.2 { 440 parse_uri file://localhost/test.db?an&unknown¶meter&is&ok 441} {/test.db {an {} unknown {} parameter {} is {} ok {}}} 442 443# EVIDENCE-OF: R-27458-04043 URI hexadecimal escape sequences (%HH) are 444# supported within the path and query components of a URI. 445# 446# EVIDENCE-OF: R-52765-50368 Before the path or query components of a 447# URI filename are interpreted, they are encoded using UTF-8 and all 448# hexadecimal escape sequences replaced by a single byte containing the 449# corresponding octet. 450# 451# The second of the two statements above is tested by creating a 452# multi-byte utf-8 character using a sequence of %HH escapes. 453# 454foreach {tn uri parse} " 455 1 {file:/test.%64%62} {/test.db {}} 456 2 {file:/test.db?%68%65%6c%6c%6f=%77%6f%72%6c%64} {/test.db {hello world}} 457 3 {file:/%C3%BF.db} {/\xFF.db {}} 458" { 459 do_filepath_test 13.$tn { parse_uri $uri } $parse 460} 461 462finish_test 463