# 2011 May 06 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # set testdir [file dirname $argv0] source $testdir/tester.tcl set testprefix e_uri db close proc parse_uri {uri} { testvfs tvfs2 testvfs tvfs tvfs filter xOpen tvfs script parse_uri_open_cb set ::uri_open [list] set DB [sqlite3_open_v2 $uri { SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_WAL } tvfs] sqlite3_close $DB tvfs delete tvfs2 delete set ::uri_open } proc parse_uri_open_cb {method file arglist} { set ::uri_open [list $file $arglist] } proc open_uri_error {uri} { set flags {SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_WAL} set DB [sqlite3_open_v2 $uri $flags ""] set e [sqlite3_errmsg $DB] sqlite3_close $DB set e } # EVIDENCE-OF: R-35840-33204 If URI filename interpretation is enabled, # and the filename argument begins with "file:", then the filename is # interpreted as a URI. # # EVIDENCE-OF: R-00067-59538 URI filename interpretation is enabled if # the SQLITE_OPEN_URI flag is is set in the fourth argument to # sqlite3_open_v2(), or if it has been enabled globally using the # SQLITE_CONFIG_URI option with the sqlite3_config() method. # if {$tcl_platform(platform) == "unix"} { set flags [list SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE] # Tests with SQLITE_CONFIG_URI configured to false. URI intepretation is # only enabled if the SQLITE_OPEN_URI flag is specified. sqlite3_shutdown sqlite3_config_uri 0 do_test 1.1 { forcedelete file:test.db test.db set DB [sqlite3_open_v2 file:test.db [concat $flags SQLITE_OPEN_URI] ""] list [file exists file:test.db] [file exists test.db] } {0 1} do_test 1.2 { forcedelete file:test.db2 test.db2 set STMT [sqlite3_prepare $DB "ATTACH 'file:test.db2' AS aux" -1 dummy] sqlite3_step $STMT sqlite3_finalize $STMT list [file exists file:test.db2] [file exists test.db2] } {0 1} sqlite3_close $DB do_test 1.3 { forcedelete file:test.db test.db set DB [sqlite3_open_v2 file:test.db [concat $flags] ""] list [file exists file:test.db] [file exists test.db] } {1 0} do_test 1.4 { forcedelete file:test.db2 test.db2 set STMT [sqlite3_prepare $DB "ATTACH 'file:test.db2' AS aux" -1 dummy] sqlite3_step $STMT sqlite3_finalize $STMT list [file exists file:test.db2] [file exists test.db2] } {1 0} sqlite3_close $DB # Tests with SQLITE_CONFIG_URI configured to true. URI intepretation is # enabled with or without SQLITE_OPEN_URI. # sqlite3_shutdown sqlite3_config_uri 1 do_test 1.5 { forcedelete file:test.db test.db set DB [sqlite3_open_v2 file:test.db [concat $flags SQLITE_OPEN_URI] ""] list [file exists file:test.db] [file exists test.db] } {0 1} do_test 1.6 { forcedelete file:test.db2 test.db2 set STMT [sqlite3_prepare $DB "ATTACH 'file:test.db2' AS aux" -1 dummy] sqlite3_step $STMT sqlite3_finalize $STMT list [file exists file:test.db2] [file exists test.db2] } {0 1} sqlite3_close $DB do_test 1.7 { forcedelete file:test.db test.db set DB [sqlite3_open_v2 file:test.db [concat $flags] ""] list [file exists file:test.db] [file exists test.db] } {0 1} do_test 1.8 { forcedelete file:test.db2 test.db2 set STMT [sqlite3_prepare $DB "ATTACH 'file:test.db2' AS aux" -1 dummy] sqlite3_step $STMT sqlite3_finalize $STMT list [file exists file:test.db2] [file exists test.db2] } {0 1} sqlite3_close $DB } # EVIDENCE-OF: R-17482-00398 If the authority is not an empty string or # "localhost", an error is returned to the caller. # if {$tcl_platform(platform) == "unix"} { set flags [list SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_URI] foreach {tn uri error} " 1 {file://localhost[pwd]/test.db} {not an error} 2 {file://[pwd]/test.db} {not an error} 3 {file://x[pwd]/test.db} {invalid uri authority: x} 4 {file://invalid[pwd]/test.db} {invalid uri authority: invalid} " { do_test 2.$tn { set DB [sqlite3_open_v2 $uri $flags ""] set e [sqlite3_errmsg $DB] sqlite3_close $DB set e } $error } } # EVIDENCE-OF: R-43804-65312 The 'fragment' component of a URI, if # present, is always ignored. # # It is difficult to test that something is ignore correctly. So these tests # just show that adding a fragment does not interfere with the pathname or # parameters passed through to the VFS xOpen() methods. # if {$tcl_platform(platform) == "unix"} { foreach {tn uri parse} " 1 {file:test.db#abc} {[pwd]/test.db {}} 2 {file:test.db?a=b#abc} {[pwd]/test.db {a b}} 3 {file:test.db?a=b#?c=d} {[pwd]/test.db {a b}} " { do_test 3.$tn { parse_uri $uri } $parse } } # EVIDENCE-OF: R-00273-20588 SQLite uses the 'path' component of the URI # as the path to the database file to open. # # EVIDENCE-OF: R-28659-11035 If the path begins with a '/' character, # then it is interpreted as an absolute path. # # EVIDENCE-OF: R-39349-47203 If it does not begin with a '/', it is # interpreted as a relative path. # if {$tcl_platform(platform) == "unix"} { foreach {tn uri parse} " 1 {file:test.db} {[pwd]/test.db {}} 2 {file:/test.db} {/test.db {}} 3 {file:///test.db} {/test.db {}} 4 {file://localhost/test.db} {/test.db {}} 5 {file:/a/b/c/test.db} {/a/b/c/test.db {}} " { do_test 4.$tn { parse_uri $uri } $parse } } # EVIDENCE-OF: R-01612-30877 The "vfs" parameter may be used to specify # the name of a VFS object that provides the operating system interface # that should be used to access the database file on disk. # # The above is tested by cases 1.* below. # # EVIDENCE-OF: R-52293-58497 If this option is set to an empty string # the default VFS object is used. # # The above is tested by cases 2.* below. # # EVIDENCE-OF: R-31855-18665 If sqlite3_open_v2() is used and the vfs # option is present, then the VFS specified by the option takes # precedence over the value passed as the fourth parameter to # sqlite3_open_v2(). # # The above is tested by cases 3.* below. # proc vfs_open_cb {name args} { set ::vfs $name } foreach {name default} {vfs1 0 vfs2 0 vfs3 1} { testvfs $name -default $default $name filter xOpen $name script [list vfs_open_cb $name] } foreach {tn uri defvfs vfs} { 1.1 "file:test.db?vfs=vfs1" "" vfs1 1.2 "file:test.db?vfs=vfs2" "" vfs2 2.1 "file:test.db" vfs1 vfs1 2.2 "file:test.db?vfs=" vfs1 vfs3 3.1 "file:test.db?vfs=vfs1" vfs2 vfs1 3.2 "file:test.db?vfs=vfs2" vfs1 vfs2 3.3 "file:test.db?xvfs=vfs1" vfs2 vfs2 3.4 "file:test.db?xvfs=vfs2" vfs1 vfs1 } { do_test 5.$tn { set flags [list SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_URI] sqlite3_close [ sqlite3_open_v2 $uri $flags $defvfs ] set ::vfs } $vfs } vfs1 delete vfs2 delete vfs3 delete # EVIDENCE-OF: R-48365-36308 Specifying an unknown VFS is an error. # set flags [list SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_URI] do_test 6.1 { set DB [sqlite3_open_v2 file:test.db?vfs=nosuchvfs $flags ""] set errmsg [sqlite3_errmsg $DB] sqlite3_close $DB set errmsg } {no such vfs: nosuchvfs} # EVIDENCE-OF: R-60479-64270 The mode parameter may be set to either # "ro", "rw" or "rwc". Attempting to set it to any other value is an # error # sqlite3 db test.db db close foreach {tn uri error} " 1 {file:test.db?mode=ro} {not an error} 2 {file:test.db?mode=rw} {not an error} 3 {file:test.db?mode=rwc} {not an error} 4 {file:test.db?mode=Ro} {no such access mode: Ro} 5 {file:test.db?mode=Rw} {no such access mode: Rw} 6 {file:test.db?mode=Rwc} {no such access mode: Rwc} " { do_test 7.$tn { open_uri_error $uri } $error } # EVIDENCE-OF: R-09651-31805 If "ro" is specified, then the database is # opened for read-only access, just as if the SQLITE_OPEN_READONLY flag # had been set in the third argument to sqlite3_prepare_v2(). # # EVIDENCE-OF: R-40137-26050 If the mode option is set to "rw", then the # database is opened for read-write (but not create) access, as if # SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had been set. # # EVIDENCE-OF: R-26845-32976 Value "rwc" is equivalent to setting both # SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. # sqlite3_shutdown sqlite3_config_uri 1 foreach {tn uri read write create} { 1 {file:test.db?mode=ro} 1 0 0 2 {file:test.db?mode=rw} 1 1 0 3 {file:test.db?mode=rwc} 1 1 1 } { set RES(c,0) {1 {unable to open database file}} set RES(c,1) {0 {}} set RES(w,0) {1 {attempt to write a readonly database}} set RES(w,1) {0 {}} set RES(r,0) {1 {this never happens}} set RES(r,1) {0 {a b}} # Test CREATE access: forcedelete test.db do_test 8.$tn.c { list [catch { sqlite3 db $uri } msg] $msg } $RES(c,$create) catch { db close } sqlite3 db test.db db eval { CREATE TABLE t1(a, b) ; INSERT INTO t1 VALUES('a', 'b') ;} db close # Test READ access: do_test 8.$tn.r { sqlite3 db $uri catchsql { SELECT * FROM t1 } } $RES(r,$read) # Test WRITE access: do_test 8.$tn.w { sqlite3 db $uri catchsql { INSERT INTO t1 VALUES(1, 2) } } $RES(w,$write) catch {db close} } # EVIDENCE-OF: R-56032-32287 If sqlite3_open_v2() is used, it is an # error to specify a value for the mode parameter that is less # restrictive than that specified by the flags passed as the third # parameter. # forcedelete test.db sqlite3 db test.db db close foreach {tn uri flags error} { 1 {file:test.db?mode=ro} ro {not an error} 2 {file:test.db?mode=ro} rw {not an error} 3 {file:test.db?mode=ro} rwc {not an error} 4 {file:test.db?mode=rw} ro {access mode not allowed: rw} 5 {file:test.db?mode=rw} rw {not an error} 6 {file:test.db?mode=rw} rwc {not an error} 7 {file:test.db?mode=rwc} ro {access mode not allowed: rwc} 8 {file:test.db?mode=rwc} rw {access mode not allowed: rwc} 9 {file:test.db?mode=rwc} rwc {not an error} } { set f(ro) [list SQLITE_OPEN_READONLY SQLITE_OPEN_URI] set f(rw) [list SQLITE_OPEN_READWRITE SQLITE_OPEN_URI] set f(rwc) [list SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_URI] set DB [sqlite3_open_v2 $uri $f($flags) ""] set e [sqlite3_errmsg $DB] sqlite3_close $DB do_test 9.$tn { set e } $error } # EVIDENCE-OF: R-23182-54295 The cache parameter may be set to either # "shared" or "private". sqlite3 db test.db db close foreach {tn uri error} " 1 {file:test.db?cache=private} {not an error} 2 {file:test.db?cache=shared} {not an error} 3 {file:test.db?cache=yes} {no such cache mode: yes} 4 {file:test.db?cache=} {no such cache mode: } " { do_test 10.$tn { open_uri_error $uri } $error } # EVIDENCE-OF: R-23027-03515 Setting it to "shared" is equivalent to # setting the SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed # to sqlite3_open_v2(). # # EVIDENCE-OF: R-49793-28525 Setting the cache parameter to "private" is # equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit. # # EVIDENCE-OF: R-19510-48080 If sqlite3_open_v2() is used and the # "cache" parameter is present in a URI filename, its value overrides # any behaviour requested by setting SQLITE_OPEN_PRIVATECACHE or # SQLITE_OPEN_SHAREDCACHE flag. # set orig [sqlite3_enable_shared_cache] foreach {tn uri flags shared_default isshared} { 1.1 "file:test.db" "" 0 0 1.2 "file:test.db" "" 1 1 1.3 "file:test.db" private 0 0 1.4 "file:test.db" private 1 0 1.5 "file:test.db" shared 0 1 1.6 "file:test.db" shared 1 1 2.1 "file:test.db?cache=private" "" 0 0 2.2 "file:test.db?cache=private" "" 1 0 2.3 "file:test.db?cache=private" private 0 0 2.4 "file:test.db?cache=private" private 1 0 2.5 "file:test.db?cache=private" shared 0 0 2.6 "file:test.db?cache=private" shared 1 0 3.1 "file:test.db?cache=shared" "" 0 1 3.2 "file:test.db?cache=shared" "" 1 1 3.3 "file:test.db?cache=shared" private 0 1 3.4 "file:test.db?cache=shared" private 1 1 3.5 "file:test.db?cache=shared" shared 0 1 3.6 "file:test.db?cache=shared" shared 1 1 } { forcedelete test.db sqlite3_enable_shared_cache 1 sqlite3 db test.db sqlite3_enable_shared_cache 0 db eval { CREATE TABLE t1(x); INSERT INTO t1 VALUES('ok'); } unset -nocomplain f set f() {SQLITE_OPEN_READWRITE SQLITE_OPEN_CREATE SQLITE_OPEN_URI} set f(shared) [concat $f() SQLITE_OPEN_SHAREDCACHE] set f(private) [concat $f() SQLITE_OPEN_PRIVATECACHE] sqlite3_enable_shared_cache $shared_default set DB [sqlite3_open_v2 $uri $f($flags) ""] set STMT [sqlite3_prepare $DB "SELECT * FROM t1" -1 dummy] db eval { BEGIN; INSERT INTO t1 VALUES('ko'); } sqlite3_step $STMT sqlite3_finalize $STMT set RES(0) {not an error} set RES(1) {database table is locked: t1} do_test 11.$tn { sqlite3_errmsg $DB } $RES($isshared) sqlite3_close $DB db close } sqlite3_enable_shared_cache $orig # EVIDENCE-OF: R-63472-46769 Specifying an unknown parameter in the # query component of a URI is not an error. # do_test 12.1 { parse_uri file://localhost/test.db?an=unknown¶meter=is&ok= } {/test.db {an unknown parameter is ok {}}} do_test 12.2 { parse_uri file://localhost/test.db?an&unknown¶meter&is&ok } {/test.db {an {} unknown {} parameter {} is {} ok {}}} # EVIDENCE-OF: R-27458-04043 URI hexadecimal escape sequences (%HH) are # supported within the path and query components of a URI. # # EVIDENCE-OF: R-52765-50368 Before the path or query components of a # URI filename are interpreted, they are encoded using UTF-8 and all # hexadecimal escape sequences replaced by a single byte containing the # corresponding octet. # # The second of the two statements above is tested by creating a # multi-byte utf-8 character using a sequence of %HH escapes. # foreach {tn uri parse} " 1 {file:/test.%64%62} {/test.db {}} 2 {file:/test.db?%68%65%6c%6c%6f=%77%6f%72%6c%64} {/test.db {hello world}} 3 {file:/%C3%BF.db} {/\xFF.db {}} " { do_test 13.$tn { parse_uri $uri } $parse } finish_test