mirror of
https://github.com/sqlite/sqlite.git
synced 2025-11-03 16:53:36 +03:00
287 lines
8.8 KiB
Plaintext
287 lines
8.8 KiB
Plaintext
# 2009 January 30
|
|
#
|
|
# 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.
|
|
#
|
|
#***********************************************************************
|
|
# This file implements regression tests for SQLite library. The
|
|
# focus of this file is testing the handling of IO errors by the
|
|
# sqlite3_backup_XXX APIs.
|
|
#
|
|
# $Id: backup_ioerr.test,v 1.3 2009/04/10 18:41:01 danielk1977 Exp $
|
|
|
|
set testdir [file dirname $argv0]
|
|
source $testdir/tester.tcl
|
|
|
|
proc data_checksum {db file} {
|
|
$db one "SELECT md5sum(a, b) FROM ${file}.t1"
|
|
}
|
|
proc test_contents {name db1 file1 db2 file2} {
|
|
$db2 eval {select * from sqlite_master}
|
|
$db1 eval {select * from sqlite_master}
|
|
set checksum [data_checksum $db2 $file2]
|
|
uplevel [list do_test $name [list data_checksum $db1 $file1] $checksum]
|
|
}
|
|
|
|
#--------------------------------------------------------------------
|
|
# This proc creates a database of approximately 290 pages. Depending
|
|
# on whether or not auto-vacuum is configured. Test cases backup_ioerr-1.*
|
|
# verify nothing more than this assumption.
|
|
#
|
|
proc populate_database {db {xtra_large 0}} {
|
|
execsql {
|
|
BEGIN;
|
|
CREATE TABLE t1(a, b);
|
|
INSERT INTO t1 VALUES(1, randstr(1000,1000));
|
|
INSERT INTO t1 SELECT a+ 1, randstr(1000,1000) FROM t1;
|
|
INSERT INTO t1 SELECT a+ 2, randstr(1000,1000) FROM t1;
|
|
INSERT INTO t1 SELECT a+ 4, randstr(1000,1000) FROM t1;
|
|
INSERT INTO t1 SELECT a+ 8, randstr(1000,1000) FROM t1;
|
|
INSERT INTO t1 SELECT a+16, randstr(1000,1000) FROM t1;
|
|
INSERT INTO t1 SELECT a+32, randstr(1000,1000) FROM t1;
|
|
CREATE INDEX i1 ON t1(b);
|
|
COMMIT;
|
|
} $db
|
|
if {$xtra_large} {
|
|
execsql { INSERT INTO t1 SELECT a+64, randstr(1000,1000) FROM t1 } $db
|
|
}
|
|
}
|
|
do_test backup_ioerr-1.1 {
|
|
populate_database db
|
|
set nPage [expr {[file size test.db] / 1024}]
|
|
expr {$nPage>130 && $nPage<160}
|
|
} {1}
|
|
do_test backup_ioerr-1.2 {
|
|
expr {[file size test.db] > $sqlite_pending_byte}
|
|
} {1}
|
|
do_test backup_ioerr-1.3 {
|
|
db close
|
|
file delete -force test.db
|
|
} {}
|
|
|
|
# Turn off IO error simulation.
|
|
#
|
|
proc clear_ioerr_simulation {} {
|
|
set ::sqlite_io_error_hit 0
|
|
set ::sqlite_io_error_hardhit 0
|
|
set ::sqlite_io_error_pending 0
|
|
set ::sqlite_io_error_persist 0
|
|
}
|
|
|
|
#--------------------------------------------------------------------
|
|
# The following procedure runs with SQLite's IO error simulation
|
|
# enabled.
|
|
#
|
|
# 1) Start with a reasonably sized database. One that includes the
|
|
# pending-byte (locking) page.
|
|
#
|
|
# 2) Open a backup process. Set the cache-size for the destination
|
|
# database to 10 pages only.
|
|
#
|
|
# 3) Step the backup process N times to partially backup the database
|
|
# file. If an IO error is reported, then the backup process is
|
|
# concluded with a call to backup_finish().
|
|
#
|
|
# If an IO error occurs, verify that:
|
|
#
|
|
# * the call to backup_step() returns an SQLITE_IOERR_XXX error code.
|
|
#
|
|
# * after the failed call to backup_step() but before the call to
|
|
# backup_finish() the destination database handle error code and
|
|
# error message remain unchanged.
|
|
#
|
|
# * the call to backup_finish() returns an SQLITE_IOERR_XXX error code.
|
|
#
|
|
# * following the call to backup_finish(), the destination database
|
|
# handle has been populated with an error code and error message.
|
|
#
|
|
# 4) Write to the database via the source database connection. Check
|
|
# that:
|
|
#
|
|
# * If an IO error occurs while writing the source database, the
|
|
# write operation should report an IO error. The backup should
|
|
# proceed as normal.
|
|
#
|
|
# * If an IO error occurs while updating the backup, the write
|
|
# operation should proceed normally. The error should be reported
|
|
# from the next call to backup_step() (in step 5 of this test
|
|
# procedure).
|
|
#
|
|
# 5) Step the backup process to finish the backup. If an IO error is
|
|
# reported, then the backup process is concluded with a call to
|
|
# backup_finish().
|
|
#
|
|
# Test that if an IO error occurs, or if one occured while updating
|
|
# the backup database during step 4, then the conditions listed
|
|
# under step 3 are all true.
|
|
#
|
|
# 6) Finish the backup process.
|
|
#
|
|
# * If the backup succeeds (backup_finish() returns SQLITE_OK), then
|
|
# the contents of the backup database should match that of the
|
|
# source database.
|
|
#
|
|
# * If the backup fails (backup_finish() returns other than SQLITE_OK),
|
|
# then the contents of the backup database should be as they were
|
|
# before the operation was started.
|
|
#
|
|
# The following factors are varied:
|
|
#
|
|
# * Destination database is initially larger than the source database, OR
|
|
# * Destination database is initially smaller than the source database.
|
|
#
|
|
# * IO errors are transient, OR
|
|
# * IO errors are persistent.
|
|
#
|
|
# * Destination page-size is smaller than the source.
|
|
# * Destination page-size is the same as the source.
|
|
# * Destination page-size is larger than the source.
|
|
#
|
|
|
|
set iTest 1
|
|
foreach bPersist {0 1} {
|
|
foreach iDestPagesize {512 1024 4096} {
|
|
foreach zSetupBak [list "" {populate_database ddb 1}] {
|
|
|
|
incr iTest
|
|
set bStop 0
|
|
for {set iError 1} {$bStop == 0} {incr iError} {
|
|
# Disable IO error simulation.
|
|
clear_ioerr_simulation
|
|
|
|
catch { ddb close }
|
|
catch { sdb close }
|
|
catch { file delete -force test.db }
|
|
catch { file delete -force bak.db }
|
|
|
|
# Open the source and destination databases.
|
|
sqlite3 sdb test.db
|
|
sqlite3 ddb bak.db
|
|
|
|
# Step 1: Populate the source and destination databases.
|
|
populate_database sdb
|
|
ddb eval "PRAGMA page_size = $iDestPagesize"
|
|
ddb eval "PRAGMA cache_size = 10"
|
|
eval $zSetupBak
|
|
|
|
# Step 2: Open the backup process.
|
|
sqlite3_backup B ddb main sdb main
|
|
|
|
# Enable IO error simulation.
|
|
set ::sqlite_io_error_pending $iError
|
|
set ::sqlite_io_error_persist $bPersist
|
|
|
|
# Step 3: Partially backup the database. If an IO error occurs, check
|
|
# a few things then skip to the next iteration of the loop.
|
|
#
|
|
set rc [B step 100]
|
|
if {$::sqlite_io_error_hardhit} {
|
|
|
|
do_test backup_ioerr-$iTest.$iError.1 {
|
|
string match SQLITE_IOERR* $rc
|
|
} {1}
|
|
do_test backup_ioerr-$iTest.$iError.2 {
|
|
list [sqlite3_errcode ddb] [sqlite3_errmsg ddb]
|
|
} {SQLITE_OK {not an error}}
|
|
|
|
set rc [B finish]
|
|
do_test backup_ioerr-$iTest.$iError.3 {
|
|
string match SQLITE_IOERR* $rc
|
|
} {1}
|
|
|
|
do_test backup_ioerr-$iTest.$iError.4 {
|
|
sqlite3_errmsg ddb
|
|
} {disk I/O error}
|
|
|
|
clear_ioerr_simulation
|
|
sqlite3 ddb bak.db
|
|
integrity_check backup_ioerr-$iTest.$iError.5 ddb
|
|
|
|
continue
|
|
}
|
|
|
|
# No IO error was encountered during step 3. Check that backup_step()
|
|
# returned SQLITE_OK before proceding.
|
|
do_test backup_ioerr-$iTest.$iError.6 {
|
|
expr {$rc eq "SQLITE_OK"}
|
|
} {1}
|
|
|
|
# Step 4: Write to the source database.
|
|
set rc [catchsql { UPDATE t1 SET b = randstr(1000,1000) WHERE a < 50 } sdb]
|
|
|
|
if {[lindex $rc 0] && $::sqlite_io_error_persist==0} {
|
|
# The IO error occured while updating the source database. In this
|
|
# case the backup should be able to continue.
|
|
set rc [B step 5000]
|
|
if { $rc != "SQLITE_IOERR_UNLOCK" } {
|
|
do_test backup_ioerr-$iTest.$iError.7 {
|
|
list [B step 5000] [B finish]
|
|
} {SQLITE_DONE SQLITE_OK}
|
|
|
|
clear_ioerr_simulation
|
|
test_contents backup_ioerr-$iTest.$iError.8 ddb main sdb main
|
|
integrity_check backup_ioerr-$iTest.$iError.9 ddb
|
|
} else {
|
|
do_test backup_ioerr-$iTest.$iError.10 {
|
|
B finish
|
|
} {SQLITE_IOERR_UNLOCK}
|
|
}
|
|
|
|
clear_ioerr_simulation
|
|
sqlite3 ddb bak.db
|
|
integrity_check backup_ioerr-$iTest.$iError.11 ddb
|
|
|
|
continue
|
|
}
|
|
|
|
# Step 5: Finish the backup operation. If an IO error occurs, check that
|
|
# it is reported correctly and skip to the next iteration of the loop.
|
|
#
|
|
set rc [B step 5000]
|
|
if {$rc != "SQLITE_DONE"} {
|
|
do_test backup_ioerr-$iTest.$iError.12 {
|
|
string match SQLITE_IOERR* $rc
|
|
} {1}
|
|
do_test backup_ioerr-$iTest.$iError.13 {
|
|
list [sqlite3_errcode ddb] [sqlite3_errmsg ddb]
|
|
} {SQLITE_OK {not an error}}
|
|
|
|
set rc [B finish]
|
|
do_test backup_ioerr-$iTest.$iError.14 {
|
|
string match SQLITE_IOERR* $rc
|
|
} {1}
|
|
do_test backup_ioerr-$iTest.$iError.15 {
|
|
sqlite3_errmsg ddb
|
|
} {disk I/O error}
|
|
|
|
clear_ioerr_simulation
|
|
sqlite3 ddb bak.db
|
|
integrity_check backup_ioerr-$iTest.$iError.16 ddb
|
|
|
|
continue
|
|
}
|
|
|
|
# The backup was successfully completed.
|
|
#
|
|
do_test backup_ioerr-$iTest.$iError.17 {
|
|
list [set rc] [B finish]
|
|
} {SQLITE_DONE SQLITE_OK}
|
|
|
|
clear_ioerr_simulation
|
|
sqlite3 sdb test.db
|
|
sqlite3 ddb bak.db
|
|
|
|
test_contents backup_ioerr-$iTest.$iError.18 ddb main sdb main
|
|
integrity_check backup_ioerr-$iTest.$iError.19 ddb
|
|
|
|
set bStop [expr $::sqlite_io_error_pending<=0]
|
|
}}}}
|
|
|
|
catch { sdb close }
|
|
catch { ddb close }
|
|
finish_test
|