Annotation of embedaddon/sqlite3/test/incrblob2.test, revision 1.1
1.1 ! misho 1: # 2008 June 9
! 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: # Test that it is possible to have two open blob handles on a single
! 13: # blob object.
! 14: #
! 15: # $Id: incrblob2.test,v 1.11 2009/06/29 06:00:37 danielk1977 Exp $
! 16: #
! 17:
! 18: set testdir [file dirname $argv0]
! 19: source $testdir/tester.tcl
! 20:
! 21: ifcapable {!autovacuum || !pragma || !incrblob} {
! 22: finish_test
! 23: return
! 24: }
! 25:
! 26: do_test incrblob2-1.0 {
! 27: execsql {
! 28: CREATE TABLE blobs(id INTEGER PRIMARY KEY, data BLOB);
! 29: INSERT INTO blobs VALUES(NULL, zeroblob(5000));
! 30: INSERT INTO blobs VALUES(NULL, zeroblob(5000));
! 31: INSERT INTO blobs VALUES(NULL, zeroblob(5000));
! 32: INSERT INTO blobs VALUES(NULL, zeroblob(5000));
! 33: }
! 34: } {}
! 35:
! 36: foreach iOffset [list 0 256 4094] {
! 37: do_test incrblob2-1.$iOffset.1 {
! 38: set fd [db incrblob blobs data 1]
! 39: puts $fd "[string repeat x $iOffset]SQLite version 3.6.0"
! 40: close $fd
! 41: } {}
! 42:
! 43: do_test incrblob2-1.$iOffset.2 {
! 44: set fd1 [db incrblob blobs data 1]
! 45: set fd2 [db incrblob blobs data 1]
! 46: fconfigure $fd1 -buffering none
! 47: fconfigure $fd2 -buffering none
! 48: if {$iOffset != 0} {
! 49: seek $fd2 $iOffset start
! 50: seek $fd1 $iOffset start
! 51: }
! 52: read $fd1 6
! 53: } {SQLite}
! 54:
! 55: do_test incrblob2-1.$iOffset.3 {
! 56: read $fd2 6
! 57: } {SQLite}
! 58:
! 59: do_test incrblob2-1.$iOffset.4 {
! 60: seek $fd2 $iOffset start
! 61: seek $fd1 $iOffset start
! 62: puts -nonewline $fd2 "etiLQS"
! 63: } {}
! 64:
! 65:
! 66: do_test incrblob2-1.$iOffset.5 {
! 67: seek $fd1 $iOffset start
! 68: read $fd1 6
! 69: } {etiLQS}
! 70:
! 71: do_test incrblob2-1.$iOffset.6 {
! 72: seek $fd2 $iOffset start
! 73: read $fd2 6
! 74: } {etiLQS}
! 75:
! 76: do_test incrblob2-1.$iOffset.7 {
! 77: seek $fd1 $iOffset start
! 78: read $fd1 6
! 79: } {etiLQS}
! 80:
! 81: do_test incrblob2-1.$iOffset.8 {
! 82: close $fd1
! 83: close $fd2
! 84: } {}
! 85: }
! 86:
! 87: #--------------------------------------------------------------------------
! 88:
! 89: foreach iOffset [list 0 256 4094] {
! 90:
! 91: do_test incrblob2-2.$iOffset.1 {
! 92: set fd1 [db incrblob blobs data 1]
! 93: seek $fd1 [expr $iOffset - 5000] end
! 94: fconfigure $fd1 -buffering none
! 95:
! 96: set fd2 [db incrblob blobs data 1]
! 97: seek $fd2 [expr $iOffset - 5000] end
! 98: fconfigure $fd2 -buffering none
! 99:
! 100: puts -nonewline $fd1 "123456"
! 101: } {}
! 102:
! 103: do_test incrblob2-2.$iOffset.2 {
! 104: read $fd2 6
! 105: } {123456}
! 106:
! 107: do_test incrblob2-2.$iOffset.3 {
! 108: close $fd1
! 109: close $fd2
! 110: } {}
! 111: }
! 112:
! 113: do_test incrblob2-3.1 {
! 114: set fd1 [db incrblob blobs data 1]
! 115: fconfigure $fd1 -buffering none
! 116: } {}
! 117: do_test incrblob2-3.2 {
! 118: execsql {
! 119: INSERT INTO blobs VALUES(5, zeroblob(10240));
! 120: }
! 121: } {}
! 122: do_test incrblob2-3.3 {
! 123: set rc [catch { read $fd1 6 } msg]
! 124: list $rc $msg
! 125: } {0 123456}
! 126: do_test incrblob2-3.4 {
! 127: close $fd1
! 128: } {}
! 129:
! 130: #--------------------------------------------------------------------------
! 131: # The following tests - incrblob2-4.* - test that blob handles are
! 132: # invalidated at the correct times.
! 133: #
! 134: do_test incrblob2-4.1 {
! 135: unset -nocomplain data
! 136: db eval BEGIN
! 137: db eval { CREATE TABLE t1(id INTEGER PRIMARY KEY, data BLOB); }
! 138: for {set ii 1} {$ii < 100} {incr ii} {
! 139: set data [string repeat "blob$ii" 500]
! 140: db eval { INSERT INTO t1 VALUES($ii, $data) }
! 141: }
! 142: db eval COMMIT
! 143: } {}
! 144:
! 145: proc aborted_handles {} {
! 146: global handles
! 147:
! 148: set aborted {}
! 149: for {set ii 1} {$ii < 100} {incr ii} {
! 150: set str "blob$ii"
! 151: set nByte [string length $str]
! 152: set iOffset [expr $nByte * $ii * 2]
! 153:
! 154: set rc [catch {sqlite3_blob_read $handles($ii) $iOffset $nByte} msg]
! 155: if {$rc && $msg eq "SQLITE_ABORT"} {
! 156: lappend aborted $ii
! 157: } else {
! 158: if {$rc || $msg ne $str} {
! 159: error "blob $ii: $msg"
! 160: }
! 161: }
! 162: }
! 163: set aborted
! 164: }
! 165:
! 166: do_test incrblob2-4.2 {
! 167: for {set ii 1} {$ii < 100} {incr ii} {
! 168: set handles($ii) [db incrblob t1 data $ii]
! 169: }
! 170: aborted_handles
! 171: } {}
! 172:
! 173: # Update row 3. This should abort handle 3 but leave all others untouched.
! 174: #
! 175: do_test incrblob2-4.3 {
! 176: db eval {UPDATE t1 SET data = data || '' WHERE id = 3}
! 177: aborted_handles
! 178: } {3}
! 179:
! 180: # Test that a write to handle 3 also returns SQLITE_ABORT.
! 181: #
! 182: do_test incrblob2-4.3.1 {
! 183: set rc [catch {sqlite3_blob_write $::handles(3) 10 HELLO} msg]
! 184: list $rc $msg
! 185: } {1 SQLITE_ABORT}
! 186:
! 187: # Delete row 14. This should abort handle 6 but leave all others untouched.
! 188: #
! 189: do_test incrblob2-4.4 {
! 190: db eval {DELETE FROM t1 WHERE id = 14}
! 191: aborted_handles
! 192: } {3 14}
! 193:
! 194: # Change the rowid of row 15 to 102. Should abort handle 15.
! 195: #
! 196: do_test incrblob2-4.5 {
! 197: db eval {UPDATE t1 SET id = 102 WHERE id = 15}
! 198: aborted_handles
! 199: } {3 14 15}
! 200:
! 201: # Clobber row 92 using INSERT OR REPLACE.
! 202: #
! 203: do_test incrblob2-4.6 {
! 204: db eval {INSERT OR REPLACE INTO t1 VALUES(92, zeroblob(1000))}
! 205: aborted_handles
! 206: } {3 14 15 92}
! 207:
! 208: # Clobber row 65 using UPDATE OR REPLACE on row 35. This should abort
! 209: # handles 35 and 65.
! 210: #
! 211: do_test incrblob2-4.7 {
! 212: db eval {UPDATE OR REPLACE t1 SET id = 65 WHERE id = 35}
! 213: aborted_handles
! 214: } {3 14 15 35 65 92}
! 215:
! 216: # Insert a couple of new rows. This should not invalidate any handles.
! 217: #
! 218: do_test incrblob2-4.9 {
! 219: db eval {INSERT INTO t1 SELECT NULL, data FROM t1}
! 220: aborted_handles
! 221: } {3 14 15 35 65 92}
! 222:
! 223: # Delete all rows from 1 to 25. This should abort all handles up to 25.
! 224: #
! 225: do_test incrblob2-4.9 {
! 226: db eval {DELETE FROM t1 WHERE id >=1 AND id <= 25}
! 227: aborted_handles
! 228: } {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 35 65 92}
! 229:
! 230: # Delete the whole table (this will use sqlite3BtreeClearTable()). All handles
! 231: # should now be aborted.
! 232: #
! 233: do_test incrblob2-4.10 {
! 234: db eval {DELETE FROM t1}
! 235: aborted_handles
! 236: } {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99}
! 237:
! 238: do_test incrblob2-4.1.X {
! 239: for {set ii 1} {$ii < 100} {incr ii} {
! 240: close $handles($ii)
! 241: }
! 242: } {}
! 243:
! 244: #--------------------------------------------------------------------------
! 245: # The following tests - incrblob2-5.* - test that in shared cache an open
! 246: # blob handle counts as a read-lock on its table.
! 247: #
! 248: ifcapable shared_cache {
! 249: db close
! 250: set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
! 251:
! 252: do_test incrblob2-5.1 {
! 253: sqlite3 db test.db
! 254: sqlite3 db2 test.db
! 255:
! 256: execsql {
! 257: INSERT INTO t1 VALUES(1, 'abcde');
! 258: }
! 259: } {}
! 260:
! 261: do_test incrblob2-5.2 {
! 262: catchsql { INSERT INTO t1 VALUES(2, 'fghij') } db2
! 263: } {0 {}}
! 264:
! 265: do_test incrblob2-5.3 {
! 266: set blob [db incrblob t1 data 1]
! 267: catchsql { INSERT INTO t1 VALUES(3, 'klmno') } db2
! 268: } {1 {database table is locked}}
! 269:
! 270: do_test incrblob2-5.4 {
! 271: close $blob
! 272: execsql BEGIN db2
! 273: catchsql { INSERT INTO t1 VALUES(4, 'pqrst') } db2
! 274: } {0 {}}
! 275:
! 276: do_test incrblob2-5.5 {
! 277: set rc [catch { db incrblob -readonly t1 data 1 } msg]
! 278: list $rc $msg
! 279: } {1 {database table is locked: t1}}
! 280:
! 281: do_test incrblob2-5.6 {
! 282: execsql { PRAGMA read_uncommitted=1 }
! 283: set blob [db incrblob -readonly t1 data 4]
! 284: read $blob
! 285: } {pqrst}
! 286:
! 287: do_test incrblob2-5.7 {
! 288: catchsql { INSERT INTO t1 VALUES(3, 'klmno') } db2
! 289: } {0 {}}
! 290:
! 291: do_test incrblob2-5.8 {
! 292: close $blob
! 293: } {}
! 294:
! 295: db2 close
! 296: db close
! 297: sqlite3_enable_shared_cache $::enable_shared_cache
! 298: }
! 299:
! 300: #--------------------------------------------------------------------------
! 301: # The following tests - incrblob2-6.* - test a specific scenario that might
! 302: # be causing an error.
! 303: #
! 304: sqlite3 db test.db
! 305: do_test incrblob2-6.1 {
! 306: execsql {
! 307: DELETE FROM t1;
! 308: INSERT INTO t1 VALUES(1, zeroblob(100));
! 309: }
! 310:
! 311: set rdHandle [db incrblob -readonly t1 data 1]
! 312: set wrHandle [db incrblob t1 data 1]
! 313:
! 314: sqlite3_blob_read $rdHandle 0 100
! 315:
! 316: sqlite3_blob_write $wrHandle 0 ABCDEF
! 317:
! 318: close $wrHandle
! 319: close $rdHandle
! 320: } {}
! 321:
! 322: do_test incrblob2-6.2 {
! 323: set rdHandle [db incrblob -readonly t1 data 1]
! 324: sqlite3_blob_read $rdHandle 0 2
! 325: } {AB}
! 326:
! 327: do_test incrblob2-6.3 {
! 328: set wrHandle [db incrblob t1 data 1]
! 329: sqlite3_blob_write $wrHandle 0 ZZZZZZZZZZ
! 330: sqlite3_blob_read $rdHandle 2 4
! 331: } {ZZZZ}
! 332:
! 333: do_test incrblob2-6.4 {
! 334: close $wrHandle
! 335: close $rdHandle
! 336: } {}
! 337:
! 338: sqlite3_memory_highwater 1
! 339: do_test incrblob2-7.1 {
! 340: db eval {
! 341: CREATE TABLE t2(B BLOB);
! 342: INSERT INTO t2 VALUES(zeroblob(10 * 1024 * 1024));
! 343: }
! 344: expr {[sqlite3_memory_highwater]<(5 * 1024 * 1024)}
! 345: } {1}
! 346:
! 347: do_test incrblob2-7.2 {
! 348: set h [db incrblob t2 B 1]
! 349: expr {[sqlite3_memory_highwater]<(5 * 1024 * 1024)}
! 350: } {1}
! 351:
! 352: do_test incrblob2-7.3 {
! 353: seek $h 0 end
! 354: tell $h
! 355: } [expr 10 * 1024 * 1024]
! 356:
! 357: do_test incrblob2-7.4 {
! 358: expr {[sqlite3_memory_highwater]<(5 * 1024 * 1024)}
! 359: } {1}
! 360:
! 361: do_test incrblob2-7.5 {
! 362: close $h
! 363: } {}
! 364:
! 365: #---------------------------------------------------------------------------
! 366: # The following tests, incrblob2-8.*, test that nothing terrible happens
! 367: # when a statement transaction is rolled back while there are open
! 368: # incremental-blob handles. At one point an assert() was failing when
! 369: # this was attempted.
! 370: #
! 371: do_test incrblob2-8.1 {
! 372: execsql BEGIN
! 373: set h [db incrblob t2 B 1]
! 374: set rc [catch {
! 375: db eval {SELECT rowid FROM t2} { execsql "DROP TABLE t2" }
! 376: } msg]
! 377: list $rc $msg
! 378: } {1 {database table is locked}}
! 379: do_test incrblob2-8.2 {
! 380: close $h
! 381: execsql COMMIT
! 382: } {}
! 383: do_test incrblob2-8.3 {
! 384: execsql {
! 385: CREATE TABLE t3(a INTEGER UNIQUE, b TEXT);
! 386: INSERT INTO t3 VALUES(1, 'aaaaaaaaaaaaaaaaaaaa');
! 387: INSERT INTO t3 VALUES(2, 'bbbbbbbbbbbbbbbbbbbb');
! 388: INSERT INTO t3 VALUES(3, 'cccccccccccccccccccc');
! 389: INSERT INTO t3 VALUES(4, 'dddddddddddddddddddd');
! 390: INSERT INTO t3 VALUES(5, 'eeeeeeeeeeeeeeeeeeee');
! 391: }
! 392: } {}
! 393: do_test incrblob2-8.4 {
! 394: execsql BEGIN
! 395: set h [db incrblob t3 b 3]
! 396: sqlite3_blob_read $h 0 20
! 397: } {cccccccccccccccccccc}
! 398: do_test incrblob2-8.5 {
! 399: catchsql {UPDATE t3 SET a = 6 WHERE a > 3}
! 400: } {1 {column a is not unique}}
! 401: do_test incrblob2-8.6 {
! 402: catchsql {UPDATE t3 SET a = 6 WHERE a > 3}
! 403: } {1 {column a is not unique}}
! 404: do_test incrblob2-8.7 {
! 405: sqlite3_blob_read $h 0 20
! 406: } {cccccccccccccccccccc}
! 407: do_test incrblob2-8.8 {
! 408: catchsql {UPDATE t3 SET a = 6 WHERE a = 3 OR a = 5}
! 409: } {1 {column a is not unique}}
! 410: do_test incrblob2-8.9 {
! 411: set rc [catch {sqlite3_blob_read $h 0 20} msg]
! 412: list $rc $msg
! 413: } {1 SQLITE_ABORT}
! 414: do_test incrblob2-8.X {
! 415: close $h
! 416: } {}
! 417:
! 418: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to incrblob2.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