summaryrefslogtreecommitdiffstats
path: root/test/backup.test
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-05 17:28:19 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-05 17:28:19 +0000
commit18657a960e125336f704ea058e25c27bd3900dcb (patch)
tree17b438b680ed45a996d7b59951e6aa34023783f2 /test/backup.test
parentInitial commit. (diff)
downloadsqlite3-18657a960e125336f704ea058e25c27bd3900dcb.tar.xz
sqlite3-18657a960e125336f704ea058e25c27bd3900dcb.zip
Adding upstream version 3.40.1.upstream/3.40.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'test/backup.test')
-rw-r--r--test/backup.test981
1 files changed, 981 insertions, 0 deletions
diff --git a/test/backup.test b/test/backup.test
new file mode 100644
index 0000000..1572ded
--- /dev/null
+++ b/test/backup.test
@@ -0,0 +1,981 @@
+# 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 sqlite3_backup_XXX API.
+#
+# $Id: backup.test,v 1.11 2009/06/05 17:09:12 drh Exp $
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+do_not_use_codec
+
+#---------------------------------------------------------------------
+# Test organization:
+#
+# backup-1.*: Warm-body tests.
+#
+# backup-2.*: Test backup under various conditions. To and from in-memory
+# databases. To and from empty/populated databases. etc.
+#
+# backup-3.*: Verify that the locking-page (pending byte page) is handled.
+#
+# backup-4.*: Test various error conditions.
+#
+# backup-5.*: Test the source database being modified during a backup.
+#
+# backup-6.*: Test the backup_remaining() and backup_pagecount() APIs.
+#
+# backup-7.*: Test SQLITE_BUSY and SQLITE_LOCKED errors.
+#
+# backup-8.*: Test multiple simultaneous backup operations.
+#
+# backup-9.*: Test that passing a negative argument to backup_step() is
+# interpreted as "copy the whole file".
+#
+# backup-10.*: Test writing the source database mid backup.
+#
+
+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]
+}
+
+do_test backup-1.1 {
+ execsql {
+ BEGIN;
+ CREATE TABLE t1(a, b);
+ CREATE INDEX i1 ON t1(a, b);
+ INSERT INTO t1 VALUES(1, randstr(1000,1000));
+ INSERT INTO t1 VALUES(2, randstr(1000,1000));
+ INSERT INTO t1 VALUES(3, randstr(1000,1000));
+ INSERT INTO t1 VALUES(4, randstr(1000,1000));
+ INSERT INTO t1 VALUES(5, randstr(1000,1000));
+ COMMIT;
+ }
+} {}
+
+# Sanity check to verify that the [test_contents] proc works.
+#
+test_contents backup-1.2 db main db main
+
+# Check that it is possible to create and finish backup operations.
+#
+do_test backup-1.3.1 {
+ delete_file test2.db
+ sqlite3 db2 test2.db
+ sqlite3_backup B db2 main db main
+} {B}
+do_test backup-1.3.2 {
+ B finish
+} {SQLITE_OK}
+do_test backup-1.3.3 {
+ info commands B
+} {}
+
+# Simplest backup operation. Backup test.db to test2.db. test2.db is
+# initially empty. test.db uses the default page size.
+#
+do_test backup-1.4.1 {
+ sqlite3_backup B db2 main db main
+} {B}
+do_test backup-1.4.2 {
+ B step 200
+} {SQLITE_DONE}
+do_test backup-1.4.3 {
+ B finish
+} {SQLITE_OK}
+do_test backup-1.4.4 {
+ info commands B
+} {}
+test_contents backup-1.4.5 db2 main db main
+db close
+db2 close
+#
+# End of backup-1.* tests.
+#---------------------------------------------------------------------
+
+
+#---------------------------------------------------------------------
+# The following tests, backup-2.*, are based on the following procedure:
+#
+# 1) Populate the source database.
+# 2) Populate the destination database.
+# 3) Run the backup to completion. (backup-2.*.1)
+# 4) Integrity check the destination db. (backup-2.*.2)
+# 5) Check that the contents of the destination db is the same as that
+# of the source db. (backup-2.*.3)
+#
+# The test is run with all possible combinations of the following
+# input parameters, except that if the destination is an in-memory
+# database, the only page size tested is 1024 bytes (the same as the
+# source page-size).
+#
+# * Source database is an in-memory database, OR
+# * Source database is a file-backed database.
+#
+# * Target database is an in-memory database, OR
+# * Target database is a file-backed database.
+#
+# * Destination database is a main file, OR
+# * Destination database is an attached file, OR
+# * Destination database is a temp database.
+#
+# * Target database is empty (zero bytes), OR
+# * Target database is larger than the source, OR
+# * Target database is smaller than the source.
+#
+# * Target database page-size is the same as the source, OR
+# * Target database page-size is larger than the source, OR
+# * Target database page-size is smaller than the source.
+#
+# * Each call to step copies a single page, OR
+# * A single call to step copies the entire source database.
+#
+set iTest 1
+foreach zSrcFile {test.db :memory:} {
+foreach zDestFile {test2.db :memory:} {
+foreach zOpenScript [list {
+ sqlite3 db $zSrcFile
+ sqlite3 db2 $zSrcFile
+ db2 eval "ATTACH '$zDestFile' AS bak"
+ set db_dest db2
+ set file_dest bak
+} {
+ sqlite3 db $zSrcFile
+ sqlite3 db2 $zDestFile
+ set db_dest db2
+ set file_dest main
+} {
+ sqlite3 db $zSrcFile
+ sqlite3 db2 $zDestFile
+ set db_dest db2
+ set file_dest temp
+}] {
+foreach rows_dest {0 3 10} {
+foreach pgsz_dest {512 1024 2048 4096} {
+foreach nPagePerStep {1 200} {
+
+ # Open the databases.
+ catch { delete_file test.db }
+ catch { delete_file test2.db }
+ eval $zOpenScript
+
+ # Set to true if copying to an in-memory destination. Copying to an
+ # in-memory destination is only possible if the initial destination
+ # page size is the same as the source page size (in this case 1024 bytes).
+ #
+ set isMemDest [expr { $zDestFile eq ":memory:" || $file_dest eq "temp" }]
+
+ if 0 {
+ puts -nonewline "Test $iTest: src=$zSrcFile dest=$zDestFile"
+ puts -nonewline " (as $db_dest.$file_dest)"
+ puts -nonewline " rows_dest=$rows_dest pgsz_dest=$pgsz_dest"
+ puts ""
+ }
+
+ if { $isMemDest==0 || $pgsz_dest==1024 || $rows_dest==0 } {
+
+ # Set up the content of the source database.
+ execsql {
+ PRAGMA page_size = 1024;
+ BEGIN;
+ CREATE TABLE t1(a, b);
+ CREATE INDEX i1 ON t1(a, b);
+ INSERT INTO t1 VALUES(1, randstr(1000,1000));
+ INSERT INTO t1 VALUES(2, randstr(1000,1000));
+ INSERT INTO t1 VALUES(3, randstr(1000,1000));
+ INSERT INTO t1 VALUES(4, randstr(1000,1000));
+ INSERT INTO t1 VALUES(5, randstr(1000,1000));
+ COMMIT;
+ }
+
+
+
+ # Set up the content of the target database.
+ execsql "PRAGMA ${file_dest}.page_size = ${pgsz_dest}" $db_dest
+ if {$rows_dest != 0} {
+ execsql "
+ BEGIN;
+ CREATE TABLE ${file_dest}.t1(a, b);
+ CREATE INDEX ${file_dest}.i1 ON t1(a, b);
+ " $db_dest
+ for {set ii 0} {$ii < $rows_dest} {incr ii} {
+ execsql "
+ INSERT INTO ${file_dest}.t1 VALUES(1, randstr(1000,1000))
+ " $db_dest
+ }
+ execsql COMMIT $db_dest
+ }
+
+ # Backup the source database.
+ do_test backup-2.$iTest.1 {
+ sqlite3_backup B $db_dest $file_dest db main
+ while {[B step $nPagePerStep]=="SQLITE_OK"} {}
+ B finish
+ } {SQLITE_OK}
+
+ # Run integrity check on the backup.
+ do_test backup-2.$iTest.2 {
+ execsql "PRAGMA ${file_dest}.integrity_check" $db_dest
+ } {ok}
+
+ test_contents backup-2.$iTest.3 db main $db_dest $file_dest
+
+ }
+
+ db close
+ catch {db2 close}
+ incr iTest
+
+} } } } } }
+#
+# End of backup-2.* tests.
+#---------------------------------------------------------------------
+
+#---------------------------------------------------------------------
+# These tests, backup-3.*, ensure that nothing goes wrong if either
+# the source or destination database are large enough to include the
+# the locking-page (the page that contains the range of bytes that
+# the locks are applied to). These tests assume that the pending
+# byte is at offset 0x00010000 (64KB offset), as set by tester.tcl,
+# not at the 1GB offset as it usually is.
+#
+# The test procedure is as follows (same procedure as used for
+# the backup-2.* tests):
+#
+# 1) Populate the source database.
+# 2) Populate the destination database.
+# 3) Run the backup to completion. (backup-3.*.1)
+# 4) Integrity check the destination db. (backup-3.*.2)
+# 5) Check that the contents of the destination db is the same as that
+# of the source db. (backup-3.*.3)
+#
+# The test procedure is run with the following parameters varied:
+#
+# * Source database includes pending-byte page.
+# * Source database does not include pending-byte page.
+#
+# * Target database includes pending-byte page.
+# * Target database does not include pending-byte page.
+#
+# * Target database page-size is the same as the source, OR
+# * Target database page-size is larger than the source, OR
+# * Target database page-size is smaller than the source.
+#
+set iTest 1
+foreach nSrcPg {10 64 65 66 100} {
+foreach nDestRow {10 100} {
+foreach nDestPgsz {512 1024 2048 4096} {
+
+ catch { delete_file test.db }
+ catch { delete_file test2.db }
+ sqlite3 db test.db
+ sqlite3 db2 test2.db
+
+ # Set up the content of the two databases.
+ #
+ execsql { PRAGMA page_size = 1024 }
+ execsql "PRAGMA page_size = $nDestPgsz" db2
+ foreach db {db db2} {
+ execsql {
+ BEGIN;
+ CREATE TABLE t1(a, b);
+ CREATE INDEX i1 ON t1(a, b);
+ COMMIT;
+ } $db
+ }
+ while {[file size test.db]/1024 < $nSrcPg} {
+ execsql { INSERT INTO t1 VALUES($ii, randstr(200,200)) }
+ }
+
+ for {set ii 0} {$ii < $nDestRow} {incr ii} {
+ execsql { INSERT INTO t1 VALUES($ii, randstr(1000,1000)) } db2
+ }
+
+ # Backup the source database.
+ do_test backup-3.$iTest.1 {
+ sqlite3_backup B db main db2 main
+ while {[B step 10]=="SQLITE_OK"} {}
+ B finish
+ } {SQLITE_OK}
+
+ # Run integrity check on the backup.
+ do_test backup-3.$iTest.2 {
+ execsql "PRAGMA integrity_check" db2
+ } {ok}
+
+ test_contents backup-3.$iTest.3 db main db2 main
+
+ db close
+ db2 close
+ incr iTest
+}
+}
+}
+
+#--------------------------------------------------------------------
+do_test backup-3.$iTest.1 {
+ catch { forcedelete test.db }
+ catch { forcedelete test2.db }
+ sqlite3 db test.db
+ set iTab 1
+
+ db eval { PRAGMA page_size = 512 }
+ while {[file size test.db] <= $::sqlite_pending_byte} {
+ db eval "CREATE TABLE t${iTab}(a, b, c)"
+ incr iTab
+ }
+
+ sqlite3 db2 test2.db
+ db2 eval { PRAGMA page_size = 4096 }
+ while {[file size test2.db] < $::sqlite_pending_byte} {
+ db2 eval "CREATE TABLE t${iTab}(a, b, c)"
+ incr iTab
+ }
+
+ sqlite3_backup B db2 main db main
+ B step -1
+} {SQLITE_DONE}
+
+do_test backup-3.$iTest.2 {
+ B finish
+} {SQLITE_OK}
+
+#
+# End of backup-3.* tests.
+#---------------------------------------------------------------------
+
+
+#---------------------------------------------------------------------
+# The following tests, backup-4.*, test various error conditions:
+#
+# backup-4.1.*: Test invalid database names.
+#
+# backup-4.2.*: Test that the source database cannot be detached while
+# a backup is in progress.
+#
+# backup-4.3.*: Test that the source database handle cannot be closed
+# while a backup is in progress.
+#
+# backup-4.4.*: Test an attempt to specify the same handle for the
+# source and destination databases.
+#
+# backup-4.5.*: Test that an in-memory destination with a different
+# page-size to the source database is an error.
+#
+sqlite3 db test.db
+sqlite3 db2 test2.db
+
+do_test backup-4.1.1 {
+ catch { sqlite3_backup B db aux db2 main }
+} {1}
+do_test backup-4.1.2 {
+ sqlite3_errmsg db
+} {unknown database aux}
+do_test backup-4.1.3 {
+ catch { sqlite3_backup B db main db2 aux }
+} {1}
+do_test backup-4.1.4 {
+ sqlite3_errmsg db
+} {unknown database aux}
+
+do_test backup-4.2.1 {
+ catch { forcedelete test3.db }
+ catch { forcedelete test4.db }
+ execsql {
+ ATTACH 'test3.db' AS aux1;
+ CREATE TABLE aux1.t1(a, b);
+ }
+ execsql {
+ ATTACH 'test4.db' AS aux2;
+ CREATE TABLE aux2.t2(a, b);
+ } db2
+ sqlite3_backup B db aux1 db2 aux2
+} {B}
+do_test backup-4.2.2 {
+ catchsql { DETACH aux2 } db2
+} {1 {database aux2 is locked}}
+do_test backup-4.2.3 {
+ B step 50
+} {SQLITE_DONE}
+do_test backup-4.2.4 {
+ B finish
+} {SQLITE_OK}
+
+do_test backup-4.3.1 {
+ sqlite3_backup B db aux1 db2 aux2
+} {B}
+do_test backup-4.3.2 {
+ db2 cache flush
+ sqlite3_close db2
+} {SQLITE_BUSY}
+do_test backup-4.3.3 {
+ sqlite3_errmsg db2
+} {unable to close due to unfinalized statements or unfinished backups}
+do_test backup-4.3.4 {
+ B step 50
+} {SQLITE_DONE}
+do_test backup-4.3.5 {
+ B finish
+} {SQLITE_OK}
+
+do_test backup-4.4.1 {
+ set rc [catch {sqlite3_backup B db main db aux1}]
+ list $rc [sqlite3_errcode db] [sqlite3_errmsg db]
+} {1 SQLITE_ERROR {source and destination must be distinct}}
+db close
+db2 close
+
+do_test backup-4.5.1 {
+ catch { forcedelete test.db }
+ sqlite3 db test.db
+ sqlite3 db2 :memory:
+ execsql {
+ CREATE TABLE t1(a, b);
+ INSERT INTO t1 VALUES(1, 2);
+ }
+ execsql {
+ PRAGMA page_size = 4096;
+ CREATE TABLE t2(a, b);
+ INSERT INTO t2 VALUES(3, 4);
+ } db2
+ sqlite3_backup B db2 main db main
+} {B}
+do_test backup-4.5.2 {
+ B step 5000
+} {SQLITE_READONLY}
+do_test backup-4.5.3 {
+ B finish
+} {SQLITE_READONLY}
+
+db close
+db2 close
+#
+# End of backup-4.* tests.
+#---------------------------------------------------------------------
+
+#---------------------------------------------------------------------
+# The following tests, backup-5.*, test that the backup works properly
+# when the source database is modified during the backup. Test cases
+# are organized as follows:
+#
+# backup-5.x.1.*: Nothing special. Modify the database mid-backup.
+#
+# backup-5.x.2.*: Modify the database mid-backup so that one or more
+# pages are written out due to cache stress. Then
+# rollback the transaction.
+#
+# backup-5.x.3.*: Database is vacuumed.
+#
+# backup-5.x.4.*: Database is vacuumed and the page-size modified.
+#
+# backup-5.x.5.*: Database is shrunk via incr-vacuum.
+#
+# Each test is run three times, in the following configurations:
+#
+# 1) Backing up file-to-file. The writer writes via an external pager.
+# 2) Backing up file-to-file. The writer writes via the same pager as
+# is used by the backup operation.
+# 3) Backing up memory-to-file.
+#
+set iTest 0
+forcedelete bak.db-wal
+foreach {writer file} {db test.db db3 test.db db :memory:} {
+ incr iTest
+ catch { delete_file bak.db }
+ sqlite3 db2 bak.db
+ catch { delete_file $file }
+ sqlite3 db $file
+ sqlite3 db3 $file
+
+ do_test backup-5.$iTest.1.1 {
+ execsql {
+ BEGIN;
+ CREATE TABLE t1(a, b);
+ CREATE INDEX i1 ON t1(a, b);
+ INSERT INTO t1 VALUES(1, randstr(1000,1000));
+ INSERT INTO t1 VALUES(2, randstr(1000,1000));
+ INSERT INTO t1 VALUES(3, randstr(1000,1000));
+ INSERT INTO t1 VALUES(4, randstr(1000,1000));
+ INSERT INTO t1 VALUES(5, randstr(1000,1000));
+ COMMIT;
+ }
+ expr {[execsql {PRAGMA page_count}] > 10}
+ } {1}
+ do_test backup-5.$iTest.1.2 {
+ sqlite3_backup B db2 main db main
+ B step 5
+ } {SQLITE_OK}
+ do_test backup-5.$iTest.1.3 {
+ execsql { UPDATE t1 SET a = a + 1 } $writer
+ B step 50
+ } {SQLITE_DONE}
+ do_test backup-5.$iTest.1.4 {
+ B finish
+ } {SQLITE_OK}
+ integrity_check backup-5.$iTest.1.5 db2
+ test_contents backup-5.$iTest.1.6 db main db2 main
+
+ do_test backup-5.$iTest.2.1 {
+ execsql {
+ PRAGMA cache_size = 10;
+ BEGIN;
+ INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1;
+ INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1;
+ INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1;
+ INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1;
+ COMMIT;
+ }
+ } {}
+ do_test backup-5.$iTest.2.2 {
+ sqlite3_backup B db2 main db main
+ B step 50
+ } {SQLITE_OK}
+ do_test backup-5.$iTest.2.3 {
+ execsql {
+ BEGIN;
+ UPDATE t1 SET a = a + 1;
+ ROLLBACK;
+ } $writer
+ B step 5000
+ } {SQLITE_DONE}
+ do_test backup-5.$iTest.2.4 {
+ B finish
+ } {SQLITE_OK}
+ integrity_check backup-5.$iTest.2.5 db2
+ test_contents backup-5.$iTest.2.6 db main db2 main
+
+ do_test backup-5.$iTest.3.1 {
+ execsql { UPDATE t1 SET b = randstr(1000,1000) }
+ } {}
+ do_test backup-5.$iTest.3.2 {
+ sqlite3_backup B db2 main db main
+ B step 50
+ } {SQLITE_OK}
+ do_test backup-5.$iTest.3.3 {
+ execsql { VACUUM } $writer
+ B step 5000
+ } {SQLITE_DONE}
+ do_test backup-5.$iTest.3.4 {
+ B finish
+ } {SQLITE_OK}
+ integrity_check backup-5.$iTest.3.5 db2
+ test_contents backup-5.$iTest.3.6 db main db2 main
+
+ do_test backup-5.$iTest.4.1 {
+ execsql { UPDATE t1 SET b = randstr(1000,1000) }
+ } {}
+ do_test backup-5.$iTest.4.2 {
+ sqlite3_backup B db2 main db main
+ B step 50
+ } {SQLITE_OK}
+ do_test backup-5.$iTest.4.3 {
+ execsql {
+ PRAGMA page_size = 2048;
+ VACUUM;
+ } $writer
+ B step 5000
+ } {SQLITE_DONE}
+ do_test backup-5.$iTest.4.4 {
+ B finish
+ } {SQLITE_OK}
+ integrity_check backup-5.$iTest.4.5 db2
+ test_contents backup-5.$iTest.4.6 db main db2 main
+
+ catch {db close}
+ catch {db2 close}
+ catch {db3 close}
+ catch { delete_file bak.db }
+ sqlite3 db2 bak.db
+ catch { delete_file $file }
+ sqlite3 db $file
+ sqlite3 db3 $file
+ do_test backup-5.$iTest.5.1 {
+ execsql {
+ PRAGMA auto_vacuum = incremental;
+ BEGIN;
+ CREATE TABLE t1(a, b);
+ CREATE INDEX i1 ON t1(a, b);
+ INSERT INTO t1 VALUES(1, randstr(1000,1000));
+ INSERT INTO t1 VALUES(2, randstr(1000,1000));
+ INSERT INTO t1 VALUES(3, randstr(1000,1000));
+ INSERT INTO t1 VALUES(4, randstr(1000,1000));
+ INSERT INTO t1 VALUES(5, randstr(1000,1000));
+ COMMIT;
+ }
+ } {}
+ do_test backup-5.$iTest.5.2 {
+ sqlite3_backup B db2 main db main
+ B step 8
+ } {SQLITE_OK}
+ do_test backup-5.$iTest.5.3 {
+ execsql {
+ DELETE FROM t1;
+ PRAGMA incremental_vacuum;
+ } $writer
+ B step 50
+ } {SQLITE_DONE}
+ do_test backup-5.$iTest.5.4 {
+ B finish
+ } {SQLITE_OK}
+ integrity_check backup-5.$iTest.5.5 db2
+ test_contents backup-5.$iTest.5.6 db main db2 main
+ catch {db close}
+ catch {db2 close}
+ catch {db3 close}
+}
+#
+# End of backup-5.* tests.
+#---------------------------------------------------------------------
+
+#---------------------------------------------------------------------
+# Test the sqlite3_backup_remaining() and backup_pagecount() APIs.
+#
+do_test backup-6.1 {
+ catch { forcedelete test.db }
+ catch { forcedelete test2.db }
+ sqlite3 db test.db
+ sqlite3 db2 test2.db
+ execsql {
+ BEGIN;
+ CREATE TABLE t1(a, b);
+ CREATE INDEX i1 ON t1(a, b);
+ INSERT INTO t1 VALUES(1, randstr(1000,1000));
+ INSERT INTO t1 VALUES(2, randstr(1000,1000));
+ INSERT INTO t1 VALUES(3, randstr(1000,1000));
+ INSERT INTO t1 VALUES(4, randstr(1000,1000));
+ INSERT INTO t1 VALUES(5, randstr(1000,1000));
+ COMMIT;
+ }
+} {}
+do_test backup-6.2 {
+ set nTotal [expr {[file size test.db]/1024}]
+ sqlite3_backup B db2 main db main
+ B step 1
+} {SQLITE_OK}
+do_test backup-6.3 {
+ B pagecount
+} $nTotal
+do_test backup-6.4 {
+ B remaining
+} [expr $nTotal-1]
+do_test backup-6.5 {
+ B step 5
+ list [B remaining] [B pagecount]
+} [list [expr $nTotal-6] $nTotal]
+do_test backup-6.6 {
+ execsql { CREATE TABLE t2(a PRIMARY KEY, b) }
+ B step 1
+ list [B remaining] [B pagecount]
+} [list [expr $nTotal-5] [expr $nTotal+2]]
+
+do_test backup-6.X {
+ B finish
+} {SQLITE_OK}
+
+catch {db close}
+catch {db2 close}
+
+#---------------------------------------------------------------------
+# Test cases backup-7.* test that SQLITE_BUSY and SQLITE_LOCKED errors
+# are returned correctly:
+#
+# backup-7.1.*: Source database is externally locked (return SQLITE_BUSY).
+#
+# backup-7.2.*: Attempt to step the backup process while a
+# write-transaction is underway on the source pager (return
+# SQLITE_LOCKED).
+#
+# backup-7.3.*: Destination database is externally locked (return SQLITE_BUSY).
+#
+do_test backup-7.0 {
+ catch { forcedelete test.db }
+ catch { forcedelete test2.db }
+ sqlite3 db2 test2.db
+ sqlite3 db test.db
+ execsql {
+ CREATE TABLE t1(a, b);
+ CREATE INDEX i1 ON 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;
+ INSERT INTO t1 SELECT a+64, randstr(1000,1000) FROM t1;
+ }
+} {}
+
+do_test backup-7.1.1 {
+ sqlite3_backup B db2 main db main
+ B step 5
+} {SQLITE_OK}
+do_test backup-7.1.2 {
+ sqlite3 db3 test.db
+ execsql { BEGIN EXCLUSIVE } db3
+ B step 5
+} {SQLITE_BUSY}
+do_test backup-7.1.3 {
+ execsql { ROLLBACK } db3
+ B step 5
+} {SQLITE_OK}
+do_test backup-7.2.1 {
+ execsql {
+ BEGIN;
+ INSERT INTO t1 VALUES(1, 4);
+ }
+} {}
+do_test backup-7.2.2 {
+ B step 5000
+} {SQLITE_BUSY}
+do_test backup-7.2.3 {
+ execsql { ROLLBACK }
+ B step 5000
+} {SQLITE_DONE}
+do_test backup-7.2.4 {
+ B finish
+} {SQLITE_OK}
+test_contents backup-7.2.5 db main db2 main
+integrity_check backup-7.3.6 db2
+
+do_test backup-7.3.1 {
+ db2 close
+ db3 close
+ forcedelete test2.db
+ sqlite3 db2 test2.db
+ sqlite3 db3 test2.db
+
+ sqlite3_backup B db2 main db main
+ execsql { BEGIN ; CREATE TABLE t2(a, b); } db3
+
+ B step 5
+} {SQLITE_BUSY}
+do_test backup-7.3.2 {
+ execsql { COMMIT } db3
+ B step 5000
+} {SQLITE_DONE}
+do_test backup-7.3.3 {
+ B finish
+} {SQLITE_OK}
+test_contents backup-7.3.4 db main db2 main
+integrity_check backup-7.3.5 db2
+catch { db2 close }
+catch { db3 close }
+
+#-----------------------------------------------------------------------
+# The following tests, backup-8.*, test attaching multiple backup
+# processes to the same source database. Also, reading from the source
+# database while a read transaction is active.
+#
+# These tests reuse the database "test.db" left over from backup-7.*.
+#
+do_test backup-8.1 {
+ catch { forcedelete test2.db }
+ catch { forcedelete test3.db }
+ sqlite3 db2 test2.db
+ sqlite3 db3 test3.db
+
+ sqlite3_backup B2 db2 main db main
+ sqlite3_backup B3 db3 main db main
+ list [B2 finish] [B3 finish]
+} {SQLITE_OK SQLITE_OK}
+do_test backup-8.2 {
+ sqlite3_backup B3 db3 main db main
+ sqlite3_backup B2 db2 main db main
+ list [B2 finish] [B3 finish]
+} {SQLITE_OK SQLITE_OK}
+do_test backup-8.3 {
+ sqlite3_backup B2 db2 main db main
+ sqlite3_backup B3 db3 main db main
+ B2 step 5
+} {SQLITE_OK}
+do_test backup-8.4 {
+ execsql {
+ BEGIN;
+ SELECT * FROM sqlite_master;
+ }
+ B3 step 5
+} {SQLITE_OK}
+do_test backup-8.5 {
+ list [B3 step 5000] [B3 finish]
+} {SQLITE_DONE SQLITE_OK}
+do_test backup-8.6 {
+ list [B2 step 5000] [B2 finish]
+} {SQLITE_DONE SQLITE_OK}
+test_contents backup-8.7 db main db2 main
+test_contents backup-8.8 db main db3 main
+do_test backup-8.9 {
+ execsql { PRAGMA lock_status }
+} {main shared temp closed}
+do_test backup-8.10 {
+ execsql COMMIT
+} {}
+catch { db2 close }
+catch { db3 close }
+
+#-----------------------------------------------------------------------
+# The following tests, backup-9.*, test that:
+#
+# * Passing 0 as an argument to sqlite3_backup_step() means no pages
+# are backed up (backup-9.1.*), and
+# * Passing a negative value as an argument to sqlite3_backup_step() means
+# all pages are backed up (backup-9.2.*).
+#
+# These tests reuse the database "test.db" left over from backup-7.*.
+#
+do_test backup-9.1.1 {
+ sqlite3 db2 test2.db
+ sqlite3_backup B db2 main db main
+ B step 1
+} {SQLITE_OK}
+do_test backup-9.1.2 {
+ set nRemaining [B remaining]
+ expr {$nRemaining>100}
+} {1}
+do_test backup-9.1.3 {
+ B step 0
+} {SQLITE_OK}
+do_test backup-9.1.4 {
+ B remaining
+} $nRemaining
+
+do_test backup-9.2.1 {
+ B step -1
+} {SQLITE_DONE}
+do_test backup-9.2.2 {
+ B remaining
+} {0}
+do_test backup-9.2.3 {
+ B finish
+} {SQLITE_OK}
+catch {db2 close}
+
+ifcapable memorymanage {
+ db close
+ forcedelete test.db
+ forcedelete bak.db
+
+ sqlite3 db test.db
+ sqlite3 db2 test.db
+ sqlite3 db3 bak.db
+
+ do_test backup-10.1.1 {
+ execsql {
+ BEGIN;
+ CREATE TABLE t1(a, b);
+ INSERT INTO t1 VALUES(1, randstr(1000,1000));
+ INSERT INTO t1 VALUES(2, randstr(1000,1000));
+ INSERT INTO t1 VALUES(3, randstr(1000,1000));
+ INSERT INTO t1 VALUES(4, randstr(1000,1000));
+ INSERT INTO t1 VALUES(5, randstr(1000,1000));
+ CREATE INDEX i1 ON t1(a, b);
+ COMMIT;
+ }
+ } {}
+ do_test backup-10.1.2 {
+ sqlite3_backup B db3 main db2 main
+ B step 5
+ } {SQLITE_OK}
+ do_test backup-10.1.3 {
+ execsql {
+ UPDATE t1 SET b = randstr(500,500);
+ }
+ } {}
+ sqlite3_release_memory [expr 1024*1024]
+ do_test backup-10.1.3 {
+ B step 50
+ } {SQLITE_DONE}
+ do_test backup-10.1.4 {
+ B finish
+ } {SQLITE_OK}
+ do_test backup-10.1.5 {
+ execsql { PRAGMA integrity_check } db3
+ } {ok}
+
+ db2 close
+ db3 close
+}
+
+
+#-----------------------------------------------------------------------
+# Test that if the database is written to via the same database handle being
+# used as the source by a backup operation:
+#
+# 10.1.*: If the db is in-memory, the backup is restarted.
+# 10.2.*: If the db is a file, the backup is not restarted.
+#
+db close
+forcedelete test.db test.db-journal
+foreach {tn file rc} {
+ 1 test.db SQLITE_DONE
+ 2 :memory: SQLITE_OK
+} {
+ do_test backup-10.$tn.1 {
+ sqlite3 db $file
+ execsql {
+ CREATE TABLE t1(a INTEGER PRIMARY KEY, b BLOB);
+ BEGIN;
+ INSERT INTO t1 VALUES(NULL, randomblob(200));
+ INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
+ INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
+ INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
+ INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
+ INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
+ INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
+ INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
+ INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
+ COMMIT;
+ SELECT count(*) FROM t1;
+ }
+ } {256}
+
+ do_test backup-10.$tn.2 {
+ set pgs [execsql {pragma page_count}]
+ expr {$pgs > 50 && $pgs < 75}
+ } {1}
+
+ do_test backup-10.$tn.3 {
+ forcedelete bak.db bak.db-journal
+ sqlite3 db2 bak.db
+ sqlite3_backup B db2 main db main
+ B step 50
+ } {SQLITE_OK}
+
+ do_test backup-10.$tn.4 {
+ execsql { UPDATE t1 SET b = randomblob(200) WHERE a IN (1, 250) }
+ } {}
+
+ do_test backup-10.$tn.5 {
+ B step 50
+ } $rc
+
+ do_test backup-10.$tn.6 {
+ B finish
+ } {SQLITE_OK}
+
+ db2 close
+}
+
+# 2021-01-31 https://sqlite.org/forum/forumpost/8b39fbf3e7
+#
+do_test backup-11.1 {
+ sqlite3 db1 :memory:
+ sqlite3 db2 :memory:
+ sqlite3_backup B db1 main db2 temp
+ B finish
+} {SQLITE_OK}
+
+finish_test