Adding the sqlite sourcecode
This commit is contained in:
Jiří Stach committed
1 parent
bdb54a1f8f
commit
406b584760
2208 files changed
+1172785
-1
No files matched your search
+195
@@ -0,0 +1,195 @@
|
||||
/*
|
||||
** 2014 August 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 contains a command-line application that uses the RBU
|
||||
** extension. See the usage() function below for an explanation.
|
||||
*/
|
||||
|
||||
#include "sqlite3rbu.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/*
|
||||
** Print a usage message and exit.
|
||||
*/
|
||||
void usage(const char *zArgv0){
|
||||
fprintf(stderr,
|
||||
"Usage: %s ?OPTIONS? TARGET-DB RBU-DB\n"
|
||||
"\n"
|
||||
"Where options are:\n"
|
||||
"\n"
|
||||
" -step NSTEP\n"
|
||||
" -statstep NSTATSTEP\n"
|
||||
" -vacuum\n"
|
||||
" -presql SQL\n"
|
||||
"\n"
|
||||
" If the -vacuum switch is not present, argument RBU-DB must be an RBU\n"
|
||||
" database containing an update suitable for target database TARGET-DB.\n"
|
||||
" Or, if -vacuum is specified, then TARGET-DB is a database to vacuum using\n"
|
||||
" RBU, and RBU-DB is used as the state database for the vacuum (refer to\n"
|
||||
" API documentation for details).\n"
|
||||
"\n"
|
||||
" If NSTEP is set to less than or equal to zero (the default value), this \n"
|
||||
" program attempts to perform the entire update or vacuum operation before\n"
|
||||
" exiting\n"
|
||||
"\n"
|
||||
" If NSTEP is greater than zero, then a maximum of NSTEP calls are made\n"
|
||||
" to sqlite3rbu_step(). If the RBU update has not been completely applied\n"
|
||||
" after the NSTEP'th call is made, the state is saved in the database RBU-DB\n"
|
||||
" and the program exits. Subsequent invocations of this (or any other RBU)\n"
|
||||
" application will use this state to resume applying the RBU update to the\n"
|
||||
" target db.\n"
|
||||
"\n"
|
||||
, zArgv0);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
void report_default_vfs(){
|
||||
sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
|
||||
fprintf(stdout, "default vfs is \"%s\"\n", pVfs ? pVfs->zName : "NULL");
|
||||
}
|
||||
|
||||
void report_rbu_vfs(sqlite3rbu *pRbu){
|
||||
sqlite3 *db = sqlite3rbu_db(pRbu, 0);
|
||||
if( db ){
|
||||
char *zName = 0;
|
||||
sqlite3_file_control(db, "main", SQLITE_FCNTL_VFSNAME, &zName);
|
||||
if( zName ){
|
||||
fprintf(stdout, "using vfs \"%s\"\n", zName);
|
||||
}else{
|
||||
fprintf(stdout, "vfs name not available\n");
|
||||
}
|
||||
sqlite3_free(zName);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv){
|
||||
int i;
|
||||
const char *zTarget; /* Target database to apply RBU to */
|
||||
const char *zRbu; /* Database containing RBU */
|
||||
char zBuf[200]; /* Buffer for printf() */
|
||||
char *zErrmsg = 0; /* Error message, if any */
|
||||
sqlite3rbu *pRbu; /* RBU handle */
|
||||
int nStep = 0; /* Maximum number of step() calls */
|
||||
int nStatStep = 0; /* Report stats after this many step calls */
|
||||
int bVacuum = 0;
|
||||
const char *zPreSql = 0;
|
||||
int rc = SQLITE_OK;
|
||||
sqlite3_int64 nProgress = 0;
|
||||
int nArgc = argc-2;
|
||||
|
||||
if( argc<3 ) usage(argv[0]);
|
||||
for(i=1; i<nArgc; i++){
|
||||
const char *zArg = argv[i];
|
||||
int nArg = strlen(zArg);
|
||||
if( nArg>1 && nArg<=8 && 0==memcmp(zArg, "-vacuum", nArg) ){
|
||||
bVacuum = 1;
|
||||
}else if( nArg>1 && nArg<=7
|
||||
&& 0==memcmp(zArg, "-presql", nArg) && i<nArg-1 ){
|
||||
i++;
|
||||
zPreSql = argv[i];
|
||||
}else if( nArg>1 && nArg<=5 && 0==memcmp(zArg, "-step", nArg) && i<nArg-1 ){
|
||||
i++;
|
||||
nStep = atoi(argv[i]);
|
||||
}else if( nArg>1 && nArg<=9
|
||||
&& 0==memcmp(zArg, "-statstep", nArg) && i<nArg-1
|
||||
){
|
||||
i++;
|
||||
nStatStep = atoi(argv[i]);
|
||||
}else{
|
||||
usage(argv[0]);
|
||||
}
|
||||
}
|
||||
|
||||
zTarget = argv[argc-2];
|
||||
zRbu = argv[argc-1];
|
||||
|
||||
report_default_vfs();
|
||||
|
||||
/* Open an RBU handle. A vacuum handle if -vacuum was specified, or a
|
||||
** regular RBU update handle otherwise. */
|
||||
if( bVacuum ){
|
||||
pRbu = sqlite3rbu_vacuum(zTarget, zRbu);
|
||||
}else{
|
||||
pRbu = sqlite3rbu_open(zTarget, zRbu, 0);
|
||||
}
|
||||
report_rbu_vfs(pRbu);
|
||||
|
||||
if( zPreSql && pRbu ){
|
||||
sqlite3 *dbMain = sqlite3rbu_db(pRbu, 0);
|
||||
rc = sqlite3_exec(dbMain, zPreSql, 0, 0, 0);
|
||||
if( rc==SQLITE_OK ){
|
||||
sqlite3 *dbRbu = sqlite3rbu_db(pRbu, 1);
|
||||
rc = sqlite3_exec(dbRbu, zPreSql, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/* If nStep is less than or equal to zero, call
|
||||
** sqlite3rbu_step() until either the RBU has been completely applied
|
||||
** or an error occurs. Or, if nStep is greater than zero, call
|
||||
** sqlite3rbu_step() a maximum of nStep times. */
|
||||
if( rc==SQLITE_OK ){
|
||||
for(i=0; (nStep<=0 || i<nStep) && sqlite3rbu_step(pRbu)==SQLITE_OK; i++){
|
||||
if( nStatStep>0 && (i % nStatStep)==0 ){
|
||||
sqlite3_int64 nUsed;
|
||||
sqlite3_int64 nHighwater;
|
||||
sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &nUsed, &nHighwater, 0);
|
||||
fprintf(stdout, "memory used=%lld highwater=%lld", nUsed, nHighwater);
|
||||
if( bVacuum==0 ){
|
||||
int one;
|
||||
int two;
|
||||
sqlite3rbu_bp_progress(pRbu, &one, &two);
|
||||
fprintf(stdout, " progress=%d/%d\n", one, two);
|
||||
}else{
|
||||
fprintf(stdout, "\n");
|
||||
}
|
||||
fflush(stdout);
|
||||
}
|
||||
}
|
||||
nProgress = sqlite3rbu_progress(pRbu);
|
||||
rc = sqlite3rbu_close(pRbu, &zErrmsg);
|
||||
}
|
||||
|
||||
/* Let the user know what happened. */
|
||||
switch( rc ){
|
||||
case SQLITE_OK:
|
||||
sqlite3_snprintf(sizeof(zBuf), zBuf,
|
||||
"SQLITE_OK: rbu update incomplete (%lld operations so far)\n",
|
||||
nProgress
|
||||
);
|
||||
fprintf(stdout, "%s", zBuf);
|
||||
break;
|
||||
|
||||
case SQLITE_DONE:
|
||||
sqlite3_snprintf(sizeof(zBuf), zBuf,
|
||||
"SQLITE_DONE: rbu update completed (%lld operations)\n",
|
||||
nProgress
|
||||
);
|
||||
fprintf(stdout, "%s", zBuf);
|
||||
break;
|
||||
|
||||
default:
|
||||
fprintf(stderr, "error=%d: %s\n", rc, zErrmsg);
|
||||
break;
|
||||
}
|
||||
|
||||
if( nStatStep>0 ){
|
||||
sqlite3_int64 nUsed;
|
||||
sqlite3_int64 nHighwater;
|
||||
sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &nUsed, &nHighwater, 0);
|
||||
fprintf(stdout, "memory used=%lld highwater=%lld\n", nUsed, nHighwater);
|
||||
}
|
||||
|
||||
sqlite3_free(zErrmsg);
|
||||
return (rc==SQLITE_OK || rc==SQLITE_DONE) ? 0 : 1;
|
||||
}
|
||||
@@ -0,0 +1,676 @@
|
||||
# 2014 August 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbu1
|
||||
|
||||
db close
|
||||
|
||||
# Create a simple RBU database. That expects to write to a table:
|
||||
#
|
||||
# CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
#
|
||||
proc create_rbu1 {filename} {
|
||||
forcedelete $filename
|
||||
sqlite3 rbu1 $filename
|
||||
rbu1 eval {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 2, 3, 0);
|
||||
INSERT INTO data_t1 VALUES(2, 'two', 'three', 0);
|
||||
INSERT INTO data_t1 VALUES(3, NULL, 8.2, 0);
|
||||
}
|
||||
rbu1 close
|
||||
return $filename
|
||||
}
|
||||
|
||||
# Create a simple RBU database. That expects to write to a table:
|
||||
#
|
||||
# CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
#
|
||||
# This RBU includes both insert and delete operations.
|
||||
#
|
||||
proc create_rbu4 {filename} {
|
||||
forcedelete $filename
|
||||
sqlite3 rbu1 $filename
|
||||
rbu1 eval {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 2, 3, 0);
|
||||
INSERT INTO data_t1 VALUES(2, NULL, 5, 1);
|
||||
INSERT INTO data_t1 VALUES(3, 8, 9, 0);
|
||||
INSERT INTO data_t1 VALUES(4, NULL, 11, 1);
|
||||
}
|
||||
rbu1 close
|
||||
return $filename
|
||||
}
|
||||
#
|
||||
# Create a simple RBU database. That expects to write to a table:
|
||||
#
|
||||
# CREATE TABLE t1(c, b, '(a)' INTEGER PRIMARY KEY);
|
||||
#
|
||||
# This RBU includes both insert and delete operations.
|
||||
#
|
||||
proc create_rbu4b {filename} {
|
||||
forcedelete $filename
|
||||
sqlite3 rbu1 $filename
|
||||
rbu1 eval {
|
||||
CREATE TABLE data_t1(c, b, '(a)', rbu_control);
|
||||
INSERT INTO data_t1 VALUES(3, 2, 1, 0);
|
||||
INSERT INTO data_t1 VALUES(5, NULL, 2, 1);
|
||||
INSERT INTO data_t1 VALUES(9, 8, 3, 0);
|
||||
INSERT INTO data_t1 VALUES(11, NULL, 4, 1);
|
||||
}
|
||||
rbu1 close
|
||||
return $filename
|
||||
}
|
||||
|
||||
# Create a simple RBU database. That expects to write to a table:
|
||||
#
|
||||
# CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
|
||||
#
|
||||
# This RBU includes update statements.
|
||||
#
|
||||
proc create_rbu5 {filename} {
|
||||
forcedelete $filename
|
||||
sqlite3 rbu5 $filename
|
||||
rbu5 eval {
|
||||
CREATE TABLE data_t1(a, b, c, d, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, NULL, NULL, 5, '...x'); -- SET d = 5
|
||||
INSERT INTO data_t1 VALUES(2, NULL, 10, 5, '..xx'); -- SET c=10, d = 5
|
||||
INSERT INTO data_t1 VALUES(3, 11, NULL, NULL, '.x..'); -- SET b=11
|
||||
}
|
||||
rbu5 close
|
||||
return $filename
|
||||
}
|
||||
|
||||
|
||||
# Same as [step_rbu], except using a URI to open the target db.
|
||||
#
|
||||
proc step_rbu_uri {target rbu} {
|
||||
while 1 {
|
||||
sqlite3rbu rbu file:$target?xyz=&abc=123 $rbu
|
||||
set rc [rbu step]
|
||||
rbu close
|
||||
if {$rc != "SQLITE_OK"} break
|
||||
}
|
||||
set rc
|
||||
}
|
||||
|
||||
# Same as [step_rbu], except using an external state database - "state.db"
|
||||
#
|
||||
proc step_rbu_state {target rbu} {
|
||||
while 1 {
|
||||
sqlite3rbu rbu $target $rbu state.db
|
||||
set rc [rbu step]
|
||||
rbu close
|
||||
if {$rc != "SQLITE_OK"} break
|
||||
}
|
||||
set rc
|
||||
}
|
||||
|
||||
proc dbfilecksum {file} {
|
||||
sqlite3 ck $file
|
||||
set cksum [dbcksum ck main]
|
||||
ck close
|
||||
set cksum
|
||||
}
|
||||
|
||||
foreach {tn3 create_vfs destroy_vfs} {
|
||||
1 {} {}
|
||||
2 {
|
||||
sqlite3rbu_create_vfs -default myrbu ""
|
||||
} {
|
||||
sqlite3rbu_destroy_vfs myrbu
|
||||
}
|
||||
3 {
|
||||
sqlite3_register_cksumvfs
|
||||
} {
|
||||
sqlite3_unregister_cksumvfs
|
||||
}
|
||||
} {
|
||||
|
||||
eval $create_vfs
|
||||
|
||||
foreach {tn2 cmd} {
|
||||
1 run_rbu
|
||||
2 step_rbu 3 step_rbu_uri 4 step_rbu_state
|
||||
5 step_rbu_legacy
|
||||
} {
|
||||
foreach {tn schema} {
|
||||
1 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
}
|
||||
2 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
}
|
||||
3 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
}
|
||||
4 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
}
|
||||
5 {
|
||||
CREATE TABLE t1(a, b, c, PRIMARY KEY(a, c)) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
}
|
||||
6 {
|
||||
CREATE TABLE t1(a, b, c, PRIMARY KEY(c)) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON t1(b, a);
|
||||
}
|
||||
7 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b, c);
|
||||
CREATE INDEX i2 ON t1(c, b);
|
||||
CREATE INDEX i3 ON t1(a, b, c, a, b, c);
|
||||
}
|
||||
|
||||
8 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b, c);
|
||||
CREATE INDEX i2 ON t1(c, b);
|
||||
CREATE INDEX i3 ON t1(a, b, c, a, b, c);
|
||||
}
|
||||
|
||||
9 {
|
||||
CREATE TABLE t1(a, b, c, PRIMARY KEY(a, c));
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
}
|
||||
|
||||
10 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b DESC);
|
||||
}
|
||||
|
||||
11 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b DESC, a ASC, c DESC);
|
||||
}
|
||||
|
||||
12 {
|
||||
CREATE TABLE t1(a INT PRIMARY KEY DESC, b, c) WITHOUT ROWID;
|
||||
}
|
||||
|
||||
13 {
|
||||
CREATE TABLE t1(a INT, b, c, PRIMARY KEY(a DESC)) WITHOUT ROWID;
|
||||
}
|
||||
|
||||
14 {
|
||||
CREATE TABLE t1(a, b, c, PRIMARY KEY(a DESC, c)) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
}
|
||||
|
||||
15 {
|
||||
CREATE TABLE t1(a, b, c, PRIMARY KEY(a, c DESC)) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
}
|
||||
|
||||
16 {
|
||||
CREATE TABLE t1(a, b, c, PRIMARY KEY(c DESC, a)) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON t1(b DESC, c, a);
|
||||
}
|
||||
} {
|
||||
reset_db
|
||||
execsql $schema
|
||||
create_rbu1 rbu.db
|
||||
set check [dbfilecksum rbu.db]
|
||||
forcedelete state.db
|
||||
|
||||
do_test $tn3.1.$tn2.$tn.1 {
|
||||
$cmd test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test $tn3.1.$tn2.$tn.2 { SELECT * FROM t1 ORDER BY a ASC } {
|
||||
1 2 3
|
||||
2 two three
|
||||
3 {} 8.2
|
||||
}
|
||||
do_execsql_test $tn3.1.$tn2.$tn.3 { SELECT * FROM t1 ORDER BY b ASC } {
|
||||
3 {} 8.2
|
||||
1 2 3
|
||||
2 two three
|
||||
}
|
||||
do_execsql_test $tn3.1.$tn2.$tn.4 { SELECT * FROM t1 ORDER BY c ASC } {
|
||||
1 2 3
|
||||
3 {} 8.2
|
||||
2 two three
|
||||
}
|
||||
|
||||
do_execsql_test $tn3.1.$tn2.$tn.5 { PRAGMA integrity_check } ok
|
||||
|
||||
if {$cmd=="step_rbu_state"} {
|
||||
do_test $tn3.1.$tn2.$tn.6 { file exists state.db } 1
|
||||
do_test $tn3.1.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 1
|
||||
} else {
|
||||
do_test $tn3.1.$tn2.$tn.8 { file exists state.db } 0
|
||||
do_test $tn3.1.$tn2.$tn.9 { expr {$check == [dbfilecksum rbu.db]} } 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Check that an RBU cannot be applied to a table that has no PK.
|
||||
#
|
||||
# UPDATE: At one point RBU required that all tables featured either
|
||||
# explicit IPK columns or were declared WITHOUT ROWID. This has been
|
||||
# relaxed so that external PRIMARY KEYs on tables with automatic rowids
|
||||
# are now allowed.
|
||||
#
|
||||
# UPDATE 2: Tables without any PRIMARY KEY declaration are now allowed.
|
||||
# However the input table must feature an "rbu_rowid" column.
|
||||
#
|
||||
reset_db
|
||||
create_rbu1 rbu.db
|
||||
do_execsql_test $tn3.2.1 { CREATE TABLE t1(a, b, c) }
|
||||
do_test $tn3.2.2 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_ERROR}
|
||||
do_test $tn3.2.3 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_ERROR - table data_t1 requires rbu_rowid column}}
|
||||
reset_db
|
||||
do_execsql_test $tn3.2.4 { CREATE TABLE t1(a PRIMARY KEY, b, c) }
|
||||
do_test $tn3.2.5 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_OK}
|
||||
do_test $tn3.2.6 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {0 SQLITE_OK}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Check that if a UNIQUE constraint is violated the current and all
|
||||
# subsequent [rbu step] calls return SQLITE_CONSTRAINT. And that the RBU
|
||||
# transaction is rolled back by the [rbu close] that deletes the rbu
|
||||
# handle.
|
||||
#
|
||||
foreach {tn errcode errmsg schema} {
|
||||
1 SQLITE_CONSTRAINT "UNIQUE constraint failed: t1.a" {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
INSERT INTO t1 VALUES(3, 2, 1);
|
||||
}
|
||||
|
||||
2 SQLITE_CONSTRAINT "UNIQUE constraint failed: t1.c" {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c UNIQUE);
|
||||
INSERT INTO t1 VALUES(4, 2, 'three');
|
||||
}
|
||||
|
||||
3 SQLITE_CONSTRAINT "UNIQUE constraint failed: t1.a" {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
INSERT INTO t1 VALUES(3, 2, 1);
|
||||
}
|
||||
|
||||
4 SQLITE_CONSTRAINT "UNIQUE constraint failed: t1.c" {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c UNIQUE);
|
||||
INSERT INTO t1 VALUES(4, 2, 'three');
|
||||
}
|
||||
|
||||
} {
|
||||
reset_db
|
||||
execsql $schema
|
||||
set cksum [dbcksum db main]
|
||||
|
||||
do_test $tn3.3.$tn.1 {
|
||||
create_rbu1 rbu.db
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while {[set res [rbu step]]=="SQLITE_OK"} {}
|
||||
set res
|
||||
} $errcode
|
||||
|
||||
do_test $tn3.3.$tn.2 { rbu step } $errcode
|
||||
|
||||
do_test $tn3.3.$tn.3 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} [list 1 "$errcode - $errmsg"]
|
||||
|
||||
do_test $tn3.3.$tn.4 { dbcksum db main } $cksum
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
foreach {tn2 cmd} {1 run_rbu 2 step_rbu 3 step_rbu_state } {
|
||||
foreach {tn schema} {
|
||||
1 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
}
|
||||
2 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
}
|
||||
3 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
CREATE INDEX i2 ON t1(c, b);
|
||||
CREATE INDEX i3 ON t1(c, b, c);
|
||||
}
|
||||
4 {
|
||||
CREATE TABLE t1(a INT PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
CREATE INDEX i2 ON t1(c, b);
|
||||
CREATE INDEX i3 ON t1(c, b, c);
|
||||
}
|
||||
5 {
|
||||
CREATE TABLE t1(a INT PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
CREATE INDEX i2 ON t1(c, b);
|
||||
CREATE INDEX i3 ON t1(c, b, c);
|
||||
}
|
||||
|
||||
6 {
|
||||
CREATE TABLE t1(a INT PRIMARY KEY DESC, b, c);
|
||||
CREATE INDEX i1 ON t1(b DESC);
|
||||
CREATE INDEX i2 ON t1(c, b);
|
||||
CREATE INDEX i3 ON t1(c DESC, b, c);
|
||||
}
|
||||
7 {
|
||||
CREATE TABLE t1(a INT PRIMARY KEY DESC, b, c) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
CREATE INDEX i2 ON t1(c, b);
|
||||
CREATE INDEX i3 ON t1(c, b, c);
|
||||
}
|
||||
} {
|
||||
reset_db
|
||||
execsql $schema
|
||||
execsql {
|
||||
INSERT INTO t1 VALUES(2, 'hello', 'world');
|
||||
INSERT INTO t1 VALUES(4, 'hello', 'planet');
|
||||
INSERT INTO t1 VALUES(6, 'hello', 'xyz');
|
||||
}
|
||||
|
||||
create_rbu4 rbu.db
|
||||
set check [dbfilecksum rbu.db]
|
||||
forcedelete state.db
|
||||
|
||||
do_test $tn3.4.$tn2.$tn.1 {
|
||||
$cmd test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test $tn3.4.$tn2.$tn.2 {
|
||||
SELECT * FROM t1 ORDER BY a ASC;
|
||||
} {
|
||||
1 2 3
|
||||
3 8 9
|
||||
6 hello xyz
|
||||
}
|
||||
|
||||
do_execsql_test $tn3.4.$tn2.$tn.3 { PRAGMA integrity_check } ok
|
||||
|
||||
if {$cmd=="step_rbu_state"} {
|
||||
do_test $tn3.4.$tn2.$tn.4 { file exists state.db } 1
|
||||
do_test $tn3.4.$tn2.$tn.5 { expr {$check == [dbfilecksum rbu.db]} } 1
|
||||
} else {
|
||||
do_test $tn3.4.$tn2.$tn.6 { file exists state.db } 0
|
||||
do_test $tn3.4.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
foreach {tn2 cmd} {1 run_rbu 2 step_rbu 3 step_rbu_state} {
|
||||
foreach {tn schema} {
|
||||
1 {
|
||||
CREATE TABLE t1(c, b, '(a)' INTEGER PRIMARY KEY);
|
||||
CREATE INDEX i1 ON t1(c, b);
|
||||
}
|
||||
2 {
|
||||
CREATE TABLE t1(c, b, '(a)' PRIMARY KEY);
|
||||
}
|
||||
3 {
|
||||
CREATE TABLE t1(c, b, '(a)' PRIMARY KEY) WITHOUT ROWID;
|
||||
}
|
||||
} {
|
||||
reset_db
|
||||
execsql $schema
|
||||
execsql {
|
||||
INSERT INTO t1('(a)', b, c) VALUES(2, 'hello', 'world');
|
||||
INSERT INTO t1('(a)', b, c) VALUES(4, 'hello', 'planet');
|
||||
INSERT INTO t1('(a)', b, c) VALUES(6, 'hello', 'xyz');
|
||||
}
|
||||
|
||||
create_rbu4b rbu.db
|
||||
set check [dbfilecksum rbu.db]
|
||||
forcedelete state.db
|
||||
|
||||
do_test $tn3.5.$tn2.$tn.1 {
|
||||
$cmd test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test $tn3.5.$tn2.$tn.2 {
|
||||
SELECT * FROM t1 ORDER BY "(a)" ASC;
|
||||
} {
|
||||
3 2 1
|
||||
9 8 3
|
||||
xyz hello 6
|
||||
}
|
||||
|
||||
do_execsql_test $tn3.4.$tn2.$tn.3 { PRAGMA integrity_check } ok
|
||||
|
||||
if {$cmd=="step_rbu_state"} {
|
||||
do_test $tn3.5.$tn2.$tn.4 { file exists state.db } 1
|
||||
do_test $tn3.5.$tn2.$tn.5 { expr {$check == [dbfilecksum rbu.db]} } 1
|
||||
} else {
|
||||
do_test $tn3.5.$tn2.$tn.6 { file exists state.db } 0
|
||||
do_test $tn3.5.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
foreach {tn2 cmd} {1 run_rbu 2 step_rbu 3 step_rbu_state} {
|
||||
foreach {tn schema} {
|
||||
1 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
|
||||
}
|
||||
2 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
|
||||
CREATE INDEX i1 ON t1(d);
|
||||
CREATE INDEX i2 ON t1(d, c);
|
||||
CREATE INDEX i3 ON t1(d, c, b);
|
||||
CREATE INDEX i4 ON t1(b);
|
||||
CREATE INDEX i5 ON t1(c);
|
||||
CREATE INDEX i6 ON t1(c, b);
|
||||
}
|
||||
3 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c, d) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON t1(d);
|
||||
CREATE INDEX i2 ON t1(d, c);
|
||||
CREATE INDEX i3 ON t1(d, c, b);
|
||||
CREATE INDEX i4 ON t1(b);
|
||||
CREATE INDEX i5 ON t1(c);
|
||||
CREATE INDEX i6 ON t1(c, b);
|
||||
}
|
||||
4 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c, d);
|
||||
CREATE INDEX i1 ON t1(d);
|
||||
CREATE INDEX i2 ON t1(d, c);
|
||||
CREATE INDEX i3 ON t1(d, c, b);
|
||||
CREATE INDEX i4 ON t1(b);
|
||||
CREATE INDEX i5 ON t1(c);
|
||||
CREATE INDEX i6 ON t1(c, b);
|
||||
}
|
||||
} {
|
||||
reset_db
|
||||
execsql $schema
|
||||
execsql {
|
||||
INSERT INTO t1 VALUES(1, 2, 3, 4);
|
||||
INSERT INTO t1 VALUES(2, 5, 6, 7);
|
||||
INSERT INTO t1 VALUES(3, 8, 9, 10);
|
||||
}
|
||||
|
||||
create_rbu5 rbu.db
|
||||
set check [dbfilecksum rbu.db]
|
||||
forcedelete state.db
|
||||
|
||||
do_test $tn3.5.$tn2.$tn.1 {
|
||||
$cmd test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test $tn3.5.$tn2.$tn.2 {
|
||||
SELECT * FROM t1 ORDER BY a ASC;
|
||||
} {
|
||||
1 2 3 5
|
||||
2 5 10 5
|
||||
3 11 9 10
|
||||
}
|
||||
|
||||
do_execsql_test $tn3.6.$tn2.$tn.3 { PRAGMA integrity_check } ok
|
||||
|
||||
if {$cmd=="step_rbu_state"} {
|
||||
do_test $tn3.6.$tn2.$tn.4 { file exists state.db } 1
|
||||
do_test $tn3.6.$tn2.$tn.5 { expr {$check == [dbfilecksum rbu.db]} } 1
|
||||
} else {
|
||||
do_test $tn3.6.$tn2.$tn.6 { file exists state.db } 0
|
||||
do_test $tn3.6.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test some error cases:
|
||||
#
|
||||
# * A virtual table with no rbu_rowid column.
|
||||
# * A no-PK table with no rbu_rowid column.
|
||||
# * A PK table with an rbu_rowid column.
|
||||
#
|
||||
# 6: An update string of the wrong length
|
||||
#
|
||||
ifcapable fts3 {
|
||||
foreach {tn schema error} {
|
||||
1 {
|
||||
CREATE TABLE t1(a, b);
|
||||
CREATE TABLE rbu.data_t1(a, b, rbu_control);
|
||||
} {SQLITE_ERROR - table data_t1 requires rbu_rowid column}
|
||||
|
||||
2 {
|
||||
CREATE VIRTUAL TABLE t1 USING fts4(a, b);
|
||||
CREATE TABLE rbu.data_t1(a, b, rbu_control);
|
||||
} {SQLITE_ERROR - table data_t1 requires rbu_rowid column}
|
||||
|
||||
3 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b);
|
||||
CREATE TABLE rbu.data_t1(a, b, rbu_rowid, rbu_control);
|
||||
} {SQLITE_ERROR - table data_t1 may not have rbu_rowid column}
|
||||
|
||||
4 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
|
||||
CREATE TABLE rbu.data_t1(a, b, rbu_rowid, rbu_control);
|
||||
} {SQLITE_ERROR - table data_t1 may not have rbu_rowid column}
|
||||
|
||||
5 {
|
||||
CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
|
||||
CREATE TABLE rbu.data_t1(a, b, rbu_rowid, rbu_control);
|
||||
} {SQLITE_ERROR - table data_t1 may not have rbu_rowid column}
|
||||
|
||||
6 {
|
||||
CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
|
||||
CREATE TABLE rbu.data_t1(a, b, rbu_control);
|
||||
INSERT INTO rbu.data_t1 VALUES(1, 2, 'x.x');
|
||||
} {SQLITE_ERROR - invalid rbu_control value}
|
||||
|
||||
7 {
|
||||
CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
|
||||
CREATE TABLE rbu.data_t1(a, b, rbu_control);
|
||||
INSERT INTO rbu.data_t1 VALUES(1, 2, NULL);
|
||||
} {SQLITE_ERROR - invalid rbu_control value}
|
||||
|
||||
8 {
|
||||
CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
|
||||
CREATE TABLE rbu.data_t1(a, b, rbu_control);
|
||||
INSERT INTO rbu.data_t1 VALUES(1, 2, 4);
|
||||
} {SQLITE_ERROR - invalid rbu_control value}
|
||||
|
||||
9 {
|
||||
CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
|
||||
CREATE TABLE rbu.data_t1(a, b, rbu_control);
|
||||
INSERT INTO rbu.data_t1 VALUES(1, 2, 3);
|
||||
} {SQLITE_ERROR - invalid rbu_control value}
|
||||
|
||||
10 {
|
||||
CREATE TABLE t2(a, b);
|
||||
CREATE TABLE rbu.data_t1(a, b, rbu_control);
|
||||
INSERT INTO rbu.data_t1 VALUES(1, 2, 2);
|
||||
} {SQLITE_ERROR - no such table: t1}
|
||||
|
||||
11 {
|
||||
CREATE TABLE rbu.data_t2(a, b, rbu_control);
|
||||
INSERT INTO rbu.data_t2 VALUES(1, 2, 2);
|
||||
} {SQLITE_ERROR - no such table: t2}
|
||||
|
||||
} {
|
||||
reset_db
|
||||
forcedelete rbu.db
|
||||
execsql { ATTACH 'rbu.db' AS rbu }
|
||||
execsql $schema
|
||||
|
||||
do_test $tn3.7.$tn {
|
||||
list [catch { run_rbu test.db rbu.db } msg] $msg
|
||||
} [list 1 $error]
|
||||
}
|
||||
}
|
||||
|
||||
# Test that an RBU database containing no input tables is handled
|
||||
# correctly.
|
||||
reset_db
|
||||
forcedelete rbu.db
|
||||
do_test $tn3.8.1 {
|
||||
list [catch { run_rbu test.db rbu.db } msg] $msg
|
||||
} {0 SQLITE_DONE}
|
||||
|
||||
# Test that an RBU database containing only empty data_xxx tables is
|
||||
# also handled correctly.
|
||||
reset_db
|
||||
forcedelete rbu.db
|
||||
do_execsql_test $tn3.8.2.1 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
CREATE TABLE data_t1(a, b, rbu_control);
|
||||
DETACH rbu;
|
||||
}
|
||||
do_test $tn3.8.2.1 {
|
||||
list [catch { run_rbu test.db rbu.db } msg] $msg
|
||||
} {0 SQLITE_DONE}
|
||||
|
||||
# Test that RBU can update indexes containing NULL values.
|
||||
#
|
||||
reset_db
|
||||
forcedelete rbu.db
|
||||
do_execsql_test $tn3.9.1 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b, c);
|
||||
INSERT INTO t1 VALUES(1, 1, NULL);
|
||||
INSERT INTO t1 VALUES(2, NULL, 2);
|
||||
INSERT INTO t1 VALUES(3, NULL, NULL);
|
||||
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, NULL, NULL, 1);
|
||||
INSERT INTO data_t1 VALUES(3, NULL, NULL, 1);
|
||||
} {}
|
||||
|
||||
do_test $tn3.9.2 {
|
||||
list [catch { run_rbu test.db rbu.db } msg] $msg
|
||||
} {0 SQLITE_DONE}
|
||||
|
||||
do_execsql_test $tn3.9.3 {
|
||||
SELECT * FROM t1
|
||||
} {2 {} 2}
|
||||
do_execsql_test $tn3.9.4 { PRAGMA integrity_check } {ok}
|
||||
|
||||
catch { db close }
|
||||
eval $destroy_vfs
|
||||
}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,184 @@
|
||||
# 2014 August 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbu10
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Test that UPDATE commands work even if the input columns are in a
|
||||
# different order to the output columns.
|
||||
#
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
INSERT INTO t1 VALUES(1, 'b', 'c');
|
||||
}
|
||||
|
||||
proc apply_rbu {sql} {
|
||||
forcedelete rbu.db
|
||||
sqlite3 db2 rbu.db
|
||||
db2 eval $sql
|
||||
db2 close
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while { [rbu step]=="SQLITE_OK" } {}
|
||||
rbu close
|
||||
}
|
||||
|
||||
do_test 1.1 {
|
||||
apply_rbu {
|
||||
CREATE TABLE data_t1(a, c, b, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 'xxx', NULL, '.x.');
|
||||
}
|
||||
db eval { SELECT * FROM t1 }
|
||||
} {1 b xxx}
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Test that the hidden languageid column of an fts4 table can be
|
||||
# written.
|
||||
#
|
||||
ifcapable fts3 {
|
||||
do_execsql_test 2.0 {
|
||||
create virtual TABLE ft USING fts4(a, b, languageid='langid');
|
||||
}
|
||||
do_test 2.1 {
|
||||
apply_rbu {
|
||||
CREATE TABLE data_ft(a, b, rbu_rowid, langid, rbu_control);
|
||||
INSERT INTO data_ft VALUES('a', 'b', 22, 1, 0); -- insert
|
||||
INSERT INTO data_ft VALUES('a', 'b', 23, 10, 0); -- insert
|
||||
INSERT INTO data_ft VALUES('a', 'b', 24, 100, 0); -- insert
|
||||
}
|
||||
db eval { SELECT a, b, rowid, langid FROM ft }
|
||||
} [list {*}{
|
||||
a b 22 1
|
||||
a b 23 10
|
||||
a b 24 100
|
||||
}]
|
||||
|
||||
# Or not - this data_xxx table has no langid column, so langid
|
||||
# defaults to 0.
|
||||
#
|
||||
do_test 2.2 {
|
||||
apply_rbu {
|
||||
CREATE TABLE data_ft(a, b, rbu_rowid, rbu_control);
|
||||
INSERT INTO data_ft VALUES('a', 'b', 25, 0); -- insert
|
||||
}
|
||||
db eval { SELECT a, b, rowid, langid FROM ft }
|
||||
} [list {*}{
|
||||
a b 22 1
|
||||
a b 23 10
|
||||
a b 24 100
|
||||
a b 25 0
|
||||
}]
|
||||
|
||||
# Update langid.
|
||||
#
|
||||
do_test 2.3 {
|
||||
apply_rbu {
|
||||
CREATE TABLE data_ft(a, b, rbu_rowid, langid, rbu_control);
|
||||
INSERT INTO data_ft VALUES(NULL, NULL, 23, 50, '..x');
|
||||
INSERT INTO data_ft VALUES(NULL, NULL, 25, 500, '..x');
|
||||
}
|
||||
db eval { SELECT a, b, rowid, langid FROM ft }
|
||||
} [list {*}{
|
||||
a b 22 1
|
||||
a b 23 50
|
||||
a b 24 100
|
||||
a b 25 500
|
||||
}]
|
||||
}
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Test that if writing a hidden virtual table column is an error,
|
||||
# attempting to do so via rbu is also an error.
|
||||
#
|
||||
ifcapable fts3 {
|
||||
do_execsql_test 3.0 {
|
||||
CREATE VIRTUAL TABLE xt USING fts4(a);
|
||||
}
|
||||
do_test 3.1 {
|
||||
list [catch {
|
||||
apply_rbu {
|
||||
CREATE TABLE data_xt(a, xt, rbu_rowid, rbu_control);
|
||||
INSERT INTO data_xt VALUES('a', 'b', 1, 0);
|
||||
}
|
||||
} msg] $msg
|
||||
} {1 {SQLITE_ERROR - SQL logic error}}
|
||||
}
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Test that it is not possible to violate a NOT NULL constraint by
|
||||
# applying an RBU update.
|
||||
#
|
||||
do_execsql_test 4.1 {
|
||||
CREATE TABLE t2(a INTEGER NOT NULL, b TEXT NOT NULL, c PRIMARY KEY);
|
||||
CREATE TABLE t3(a INTEGER NOT NULL, b TEXT NOT NULL, c INTEGER PRIMARY KEY);
|
||||
CREATE TABLE t4(a, b, PRIMARY KEY(a, b)) WITHOUT ROWID;
|
||||
|
||||
INSERT INTO t2 VALUES(10, 10, 10);
|
||||
INSERT INTO t3 VALUES(10, 10, 10);
|
||||
INSERT INTO t4 VALUES(10, 10);
|
||||
}
|
||||
|
||||
foreach {tn error rbu} {
|
||||
2 {SQLITE_CONSTRAINT - NOT NULL constraint failed: t2.a} {
|
||||
INSERT INTO data_t2 VALUES(NULL, 'abc', 1, 0);
|
||||
}
|
||||
3 {SQLITE_CONSTRAINT - NOT NULL constraint failed: t2.b} {
|
||||
INSERT INTO data_t2 VALUES(2, NULL, 1, 0);
|
||||
}
|
||||
4 {SQLITE_CONSTRAINT - NOT NULL constraint failed: t2.c} {
|
||||
INSERT INTO data_t2 VALUES(1, 'abc', NULL, 0);
|
||||
}
|
||||
|
||||
5 {SQLITE_MISMATCH - datatype mismatch} {
|
||||
INSERT INTO data_t3 VALUES(1, 'abc', NULL, 0);
|
||||
}
|
||||
|
||||
6 {SQLITE_CONSTRAINT - NOT NULL constraint failed: t4.b} {
|
||||
INSERT INTO data_t4 VALUES('a', NULL, 0);
|
||||
}
|
||||
7 {SQLITE_CONSTRAINT - NOT NULL constraint failed: t4.a} {
|
||||
INSERT INTO data_t4 VALUES(NULL, 'a', 0);
|
||||
}
|
||||
8 {SQLITE_CONSTRAINT - NOT NULL constraint failed: t2.a} {
|
||||
INSERT INTO data_t2 VALUES(NULL, 0, 10, 'x..');
|
||||
}
|
||||
9 {SQLITE_CONSTRAINT - NOT NULL constraint failed: t3.b} {
|
||||
INSERT INTO data_t3 VALUES(10, NULL, 10, '.x.');
|
||||
}
|
||||
|
||||
10 {SQLITE_MISMATCH - datatype mismatch} {
|
||||
INSERT INTO data_t3 VALUES(1, 'abc', 'text', 0);
|
||||
}
|
||||
} {
|
||||
set rbu "
|
||||
CREATE TABLE data_t2(a, b, c, rbu_control);
|
||||
CREATE TABLE data_t3(a, b, c, rbu_control);
|
||||
CREATE TABLE data_t4(a, b, rbu_control);
|
||||
$rbu
|
||||
"
|
||||
do_test 4.2.$tn {
|
||||
list [catch { apply_rbu $rbu } msg] $msg
|
||||
} [list 1 $error]
|
||||
}
|
||||
|
||||
do_test 4.3 {
|
||||
set rbu {
|
||||
CREATE TABLE data_t3(a, b, c, rbu_control);
|
||||
INSERT INTO data_t3 VALUES(1, 'abc', '5', 0);
|
||||
INSERT INTO data_t3 VALUES(1, 'abc', '-6.0', 0);
|
||||
}
|
||||
list [catch { apply_rbu $rbu } msg] $msg
|
||||
} {0 SQLITE_DONE}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,195 @@
|
||||
# 2015 February 16
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbu11
|
||||
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Test that the xAccess() method of an rbu vfs handles queries other
|
||||
# than SQLITE_ACCESS_EXISTS correctly. The test code below causes
|
||||
# SQLite to call xAccess(SQLITE_ACCESS_READWRITE) on the directory
|
||||
# path argument passed to "PRAGMA temp_store_directory".
|
||||
#
|
||||
do_test 1.1 {
|
||||
sqlite3rbu_create_vfs -default rbu ""
|
||||
reset_db
|
||||
catchsql { PRAGMA temp_store_directory = '/no/such/directory' }
|
||||
} {1 {not a writable directory}}
|
||||
|
||||
do_test 1.2 {
|
||||
catchsql " PRAGMA temp_store_directory = '[pwd]' "
|
||||
} {0 {}}
|
||||
|
||||
do_test 1.3 {
|
||||
catchsql " PRAGMA temp_store_directory = '' "
|
||||
} {0 {}}
|
||||
|
||||
do_test 1.4 {
|
||||
db close
|
||||
sqlite3rbu_destroy_vfs rbu
|
||||
} {}
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Try to trick rbu into operating on a database opened in wal mode.
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 2.1 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
PRAGMA journal_mode = 'wal';
|
||||
CREATE TABLE t2(d PRIMARY KEY, e, f);
|
||||
} {wal}
|
||||
|
||||
do_test 2.2 {
|
||||
db_save
|
||||
db close
|
||||
|
||||
forcedelete rbu.db
|
||||
sqlite3 dbo rbu.db
|
||||
dbo eval {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(4, 5, 6, 0);
|
||||
INSERT INTO data_t1 VALUES(7, 8, 9, 0);
|
||||
}
|
||||
dbo close
|
||||
|
||||
db_restore
|
||||
hexio_write test.db 18 0101
|
||||
file exists test.db-wal
|
||||
} {1}
|
||||
|
||||
do_test 2.3 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_ERROR}
|
||||
|
||||
do_test 2.4 {
|
||||
list [catch {rbu close} msg] $msg
|
||||
} {1 {SQLITE_ERROR - cannot update wal mode database}}
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Test a constraint violation message with an unusual table name.
|
||||
# Specifically, one for which the first character is a codepoint
|
||||
# smaller than 30 (character '0').
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 3.1 {
|
||||
CREATE TABLE "(t1)"(a PRIMARY KEY, b, c);
|
||||
INSERT INTO "(t1)" VALUES(1, 2, 3);
|
||||
INSERT INTO "(t1)" VALUES(4, 5, 6);
|
||||
}
|
||||
db close
|
||||
|
||||
do_test 3.2 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 dbo rbu.db
|
||||
dbo eval {
|
||||
CREATE TABLE "data_(t1)"(a, b, c, rbu_control);
|
||||
INSERT INTO "data_(t1)" VALUES(4, 8, 9, 0);
|
||||
}
|
||||
dbo close
|
||||
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
rbu step
|
||||
} {SQLITE_CONSTRAINT}
|
||||
|
||||
do_test 3.3 {
|
||||
list [catch {rbu close} msg] $msg
|
||||
} {1 {SQLITE_CONSTRAINT - UNIQUE constraint failed: (t1).a}}
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Check that once an RBU update has been applied, attempting to apply
|
||||
# it a second time is a no-op (as the state stored in the RBU database is
|
||||
# "all steps completed").
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 4.1 {
|
||||
CREATE TABLE "(t1)"(a, b, c, PRIMARY KEY(c, b, a));
|
||||
INSERT INTO "(t1)" VALUES(1, 2, 3);
|
||||
INSERT INTO "(t1)" VALUES(4, 5, 6);
|
||||
}
|
||||
db close
|
||||
|
||||
do_test 4.2 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 dbo rbu.db
|
||||
dbo eval {
|
||||
CREATE TABLE "data_(t1)"(a, b, c, rbu_control);
|
||||
INSERT INTO "data_(t1)" VALUES(7, 8, 9, 0);
|
||||
INSERT INTO "data_(t1)" VALUES(1, 2, 3, 1);
|
||||
}
|
||||
dbo close
|
||||
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while {[rbu step]=="SQLITE_OK"} { }
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 4.3 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 4.4 {
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 4.5.1 {
|
||||
sqlite3 dbo rbu.db
|
||||
dbo eval { INSERT INTO rbu_state VALUES(100, 100) }
|
||||
dbo close
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_CORRUPT}
|
||||
do_test 4.5.2 {
|
||||
list [catch {rbu close} msg] $msg
|
||||
} {1 SQLITE_CORRUPT}
|
||||
do_test 4.5.3 {
|
||||
sqlite3 dbo rbu.db
|
||||
dbo eval { DELETE FROM rbu_state WHERE k = 100 }
|
||||
dbo close
|
||||
} {}
|
||||
|
||||
# Also, check that an invalid state value in the rbu_state table is
|
||||
# detected and reported as corruption.
|
||||
do_test 4.6.1 {
|
||||
sqlite3 dbo rbu.db
|
||||
dbo eval { UPDATE rbu_state SET v = v*-1 WHERE k = 1 }
|
||||
dbo close
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_CORRUPT}
|
||||
do_test 4.6.2 {
|
||||
list [catch {rbu close} msg] $msg
|
||||
} {1 SQLITE_CORRUPT}
|
||||
do_test 4.6.3 {
|
||||
sqlite3 dbo rbu.db
|
||||
dbo eval { UPDATE rbu_state SET v = v*-1 WHERE k = 1 }
|
||||
dbo close
|
||||
} {}
|
||||
|
||||
do_test 4.7.1 {
|
||||
sqlite3 dbo rbu.db
|
||||
dbo eval { UPDATE rbu_state SET v = 1 WHERE k = 1 }
|
||||
dbo eval { UPDATE rbu_state SET v = 'nosuchtable' WHERE k = 2 }
|
||||
dbo close
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_ERROR}
|
||||
do_test 4.7.2 {
|
||||
list [catch {rbu close} msg] $msg
|
||||
} {1 {SQLITE_ERROR - rbu_state mismatch error}}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,232 @@
|
||||
# 2015 February 16
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
source $testdir/lock_common.tcl
|
||||
set ::testprefix rbu12
|
||||
|
||||
set setup_sql {
|
||||
DROP TABLE IF EXISTS xx;
|
||||
DROP TABLE IF EXISTS xy;
|
||||
CREATE TABLE xx(a, b, c PRIMARY KEY);
|
||||
INSERT INTO xx VALUES(1, 2, 3);
|
||||
CREATE TABLE xy(a, b, c PRIMARY KEY);
|
||||
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
DROP TABLE IF EXISTS data_xx;
|
||||
CREATE TABLE rbu.data_xx(a, b, c, rbu_control);
|
||||
INSERT INTO data_xx VALUES(4, 5, 6, 0);
|
||||
INSERT INTO data_xx VALUES(7, 8, 9, 0);
|
||||
CREATE TABLE rbu.data_xy(a, b, c, rbu_control);
|
||||
INSERT INTO data_xy VALUES(10, 11, 12, 0);
|
||||
DETACH rbu;
|
||||
}
|
||||
|
||||
do_multiclient_test tn {
|
||||
|
||||
# Initialize a target (test.db) and rbu (rbu.db) database.
|
||||
#
|
||||
forcedelete rbu.db
|
||||
sql1 $setup_sql
|
||||
|
||||
# Using connection 2, open a read transaction on the target database.
|
||||
# RBU will still be able to generate "test.db-oal", but it will not be
|
||||
# able to rename it to "test.db-wal".
|
||||
#
|
||||
do_test 1.$tn.1 {
|
||||
sql2 { BEGIN; SELECT * FROM xx; }
|
||||
} {1 2 3}
|
||||
do_test 1.$tn.2 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while 1 {
|
||||
set res [rbu step]
|
||||
if {$res!="SQLITE_OK"} break
|
||||
}
|
||||
set res
|
||||
} {SQLITE_BUSY}
|
||||
|
||||
do_test 1.$tn.3 { sql2 { SELECT * FROM xx; } } {1 2 3}
|
||||
do_test 1.$tn.4 { sql2 { SELECT * FROM xy; } } {}
|
||||
do_test 1.$tn.5 {
|
||||
list [file exists test.db-wal] [file exists test.db-oal]
|
||||
} {0 1}
|
||||
do_test 1.$tn.6 { sql2 COMMIT } {}
|
||||
|
||||
# The rbu object that hit the SQLITE_BUSY error above cannot be reused.
|
||||
# It is stuck in a permanent SQLITE_BUSY state at this point.
|
||||
#
|
||||
do_test 1.$tn.7 { rbu step } {SQLITE_BUSY}
|
||||
do_test 1.$tn.8 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 SQLITE_BUSY}
|
||||
|
||||
do_test 1.$tn.9.1 { sql2 { BEGIN EXCLUSIVE } } {}
|
||||
do_test 1.$tn.9.2 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_BUSY}
|
||||
do_test 1.$tn.9.3 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_BUSY - database is locked}}
|
||||
do_test 1.$tn.9.4 { sql2 COMMIT } {}
|
||||
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
do_test 1.$tn.10.1 { sql2 { BEGIN EXCLUSIVE } } {}
|
||||
do_test 1.$tn.10.2 {
|
||||
rbu step
|
||||
} {SQLITE_BUSY}
|
||||
do_test 1.$tn.10.3 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 SQLITE_BUSY}
|
||||
do_test 1.$tn.10.4 { sql2 COMMIT } {}
|
||||
|
||||
# A new rbu object can finish the work though.
|
||||
#
|
||||
do_test 1.$tn.11 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_OK}
|
||||
do_test 1.$tn.12 {
|
||||
list [file exists test.db-wal] [file exists test.db-oal]
|
||||
} {1 0}
|
||||
do_test 1.$tn.13 {
|
||||
while 1 {
|
||||
set res [rbu step]
|
||||
if {$res!="SQLITE_OK"} break
|
||||
}
|
||||
set res
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 1.$tn.14 {
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
}
|
||||
|
||||
do_multiclient_test tn {
|
||||
|
||||
# Initialize a target (test.db) and rbu (rbu.db) database.
|
||||
#
|
||||
forcedelete rbu.db
|
||||
sql1 $setup_sql
|
||||
|
||||
do_test 2.$tn.1 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while {[file exists test.db-wal]==0} {
|
||||
if {[rbu step]!="SQLITE_OK"} {error "problem here...."}
|
||||
}
|
||||
rbu close
|
||||
} {SQLITE_OK}
|
||||
|
||||
|
||||
do_test 2.$tn.2 { sql2 { BEGIN IMMEDIATE } } {}
|
||||
|
||||
do_test 2.$tn.3 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_BUSY}
|
||||
|
||||
do_test 2.$tn.4 { list [catch { rbu close } msg] $msg } {1 SQLITE_BUSY}
|
||||
|
||||
do_test 2.$tn.5 {
|
||||
sql2 { SELECT * FROM xx ; COMMIT }
|
||||
} {1 2 3 4 5 6 7 8 9}
|
||||
|
||||
do_test 2.$tn.6 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
rbu close
|
||||
} {SQLITE_OK}
|
||||
|
||||
do_test 2.$tn.7 { sql2 { BEGIN EXCLUSIVE } } {}
|
||||
|
||||
do_test 2.$tn.8 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_BUSY}
|
||||
do_test 2.$tn.9 { list [catch { rbu close } msg] $msg } {1 SQLITE_BUSY}
|
||||
do_test 2.$tn.10 {
|
||||
sql2 { SELECT * FROM xx ; COMMIT }
|
||||
} {1 2 3 4 5 6 7 8 9}
|
||||
|
||||
do_test 2.$tn.11 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that "PRAGMA data_version" works when an RBU client writes the
|
||||
# database.
|
||||
#
|
||||
do_multiclient_test tn {
|
||||
|
||||
# Initialize a target (test.db) and rbu (rbu.db) database.
|
||||
#
|
||||
forcedelete rbu.db
|
||||
sql1 $setup_sql
|
||||
|
||||
# Check the initial database contains table "xx" with a single row.
|
||||
# Also save the current values of "PRAGMA data-version" for [db1]
|
||||
# and [db2].
|
||||
#
|
||||
do_test 2.$tn.1 {
|
||||
list [sql1 { SELECT count(*) FROM xx }] [sql2 { SELECT count(*) FROM xx }]
|
||||
} {1 1}
|
||||
set V1 [sql1 {PRAGMA data_version}]
|
||||
set V2 [sql2 {PRAGMA data_version}]
|
||||
|
||||
# Check the values of data-version have not magically changed.
|
||||
#
|
||||
do_test 2.$tn.2 {
|
||||
list [sql1 {PRAGMA data_version}] [sql2 {PRAGMA data_version}]
|
||||
} [list $V1 $V2]
|
||||
|
||||
# Start stepping the RBU. From the point of view of [db1] and [db2], the
|
||||
# data-version values remain unchanged until the database contents are
|
||||
# modified. At which point the values are incremented.
|
||||
#
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
set x 0
|
||||
while {[db one {SELECT count(*) FROM xx}]==1} {
|
||||
do_test 2.$tn.3.[incr x] {
|
||||
list [sql1 {PRAGMA data_version}] [sql2 {PRAGMA data_version}]
|
||||
} [list $V1 $V2]
|
||||
rbu step
|
||||
}
|
||||
do_test 2.$tn.5.1 { expr {$V1 < [sql1 {PRAGMA data_version}]} } 1
|
||||
do_test 2.$tn.5.2 { expr {$V2 < [sql2 {PRAGMA data_version}]} } 1
|
||||
|
||||
# Check the db contents is as expected.
|
||||
#
|
||||
do_test 2.$tn.4 {
|
||||
list [sql1 {SELECT count(*) FROM xx}] [sql2 {SELECT count(*) FROM xx}]
|
||||
} {3 3}
|
||||
|
||||
set V1 [sql1 {PRAGMA data_version}]
|
||||
set V2 [sql2 {PRAGMA data_version}]
|
||||
|
||||
# Finish applying the RBU (i.e. do the incremental checkpoint). Check that
|
||||
# this does not cause the data-version values to change.
|
||||
#
|
||||
while {[rbu step]=="SQLITE_OK"} { }
|
||||
rbu close
|
||||
|
||||
do_test 2.$tn.6 {
|
||||
list [sql1 {PRAGMA data_version}] [sql2 {PRAGMA data_version}]
|
||||
} [list $V1 $V2]
|
||||
|
||||
}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,62 @@
|
||||
# 2015 February 16
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
# Test an RBU update that features lots of different rbu_control strings
|
||||
# for UPDATE statements. This tests RBU's internal UPDATE statement cache.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
source $testdir/lock_common.tcl
|
||||
set ::testprefix rbu13
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c, d, e, f, g, h);
|
||||
WITH ii(i) AS (SELECT 0 UNION ALL SELECT i+1 FROM ii WHERE i<127)
|
||||
INSERT INTO t1 SELECT i, 0, 0, 0, 0, 0, 0, 0 FROM ii;
|
||||
}
|
||||
|
||||
forcedelete rbu.db
|
||||
do_execsql_test 1.1 {
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
CREATE TABLE rbu.data_t1(a, b, c, d, e, f, g, h, rbu_control);
|
||||
}
|
||||
|
||||
do_test 1.2 {
|
||||
for {set i 0} {$i<128} {incr i} {
|
||||
set control "."
|
||||
for {set bit 6} {$bit>=0} {incr bit -1} {
|
||||
if { $i & (1<<$bit) } {
|
||||
append control "x"
|
||||
} else {
|
||||
append control "."
|
||||
}
|
||||
}
|
||||
execsql { INSERT INTO data_t1 VALUES($i, 1, 1, 1, 1, 1, 1, 1, $control) }
|
||||
}
|
||||
} {}
|
||||
|
||||
do_test 1.3 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while 1 {
|
||||
set rc [rbu step]
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 1.4 {
|
||||
SELECT count(*) FROM t1 WHERE
|
||||
a == ( (b<<6) + (c<<5) + (d<<4) + (e<<3) + (f<<2) + (g<<1) + (h<<0) )
|
||||
} {128}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,92 @@
|
||||
# 2015 July 25
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
# Test that an RBU data_xxx table may be a view instead of a regular
|
||||
# table.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
source $testdir/lock_common.tcl
|
||||
set ::testprefix rbu14
|
||||
|
||||
|
||||
foreach {tn schema} {
|
||||
1 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
CREATE TABLE t2(a PRIMARY KEY, b, c);
|
||||
}
|
||||
2 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
CREATE TABLE t2(a PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b, c);
|
||||
CREATE INDEX i2 ON t2(b, c);
|
||||
}
|
||||
3 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
CREATE TABLE t2(a PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
}
|
||||
4 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
CREATE TABLE t2(a PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON t1(b, c);
|
||||
CREATE INDEX i2 ON t2(b, c);
|
||||
}
|
||||
} {
|
||||
reset_db
|
||||
|
||||
execsql $schema
|
||||
execsql {
|
||||
INSERT INTO t1 VALUES(50, 50, 50);
|
||||
INSERT INTO t1 VALUES(51, 51, 51);
|
||||
INSERT INTO t2 VALUES(50, 50, 50);
|
||||
INSERT INTO t2 VALUES(51, 51, 51);
|
||||
}
|
||||
|
||||
forcedelete rbu.db
|
||||
do_execsql_test $tn.1 {
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
CREATE TABLE rbu.stuff(tbl, a, b, c, rbu_control);
|
||||
INSERT INTO stuff VALUES
|
||||
('t1', 1, 2, 3, 0), -- insert into t1
|
||||
('t2', 4, 5, 6, 0), -- insert into t2
|
||||
('t1', 50, NULL, NULL, 1), -- delete from t1
|
||||
('t2', 51, NULL, NULL, 1); -- delete from t2
|
||||
|
||||
CREATE VIEW rbu.data_t1 AS
|
||||
SELECT a, b, c, rbu_control FROM stuff WHERE tbl='t1';
|
||||
CREATE VIEW rbu.data_t2 AS
|
||||
SELECT a, b, c, rbu_control FROM stuff WHERE tbl='t2';
|
||||
}
|
||||
|
||||
do_test $tn.2 {
|
||||
while 1 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
set rc [rbu step]
|
||||
rbu close
|
||||
if {$rc != "SQLITE_OK"} break
|
||||
}
|
||||
set rc
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test $tn.3.1 {
|
||||
SELECT * FROM t1 ORDER BY a;
|
||||
} {1 2 3 51 51 51}
|
||||
|
||||
do_execsql_test $tn.3.2 {
|
||||
SELECT * FROM t2 ORDER BY a;
|
||||
} {4 5 6 50 50 50}
|
||||
|
||||
integrity_check $tn.4
|
||||
}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,200 @@
|
||||
# 2014 August 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbu3
|
||||
|
||||
|
||||
# Run the RBU in file $rbu on target database $target until completion.
|
||||
#
|
||||
proc run_rbu {target rbu} {
|
||||
sqlite3rbu rbu $target $rbu
|
||||
while { [rbu step]=="SQLITE_OK" } {}
|
||||
rbu close
|
||||
}
|
||||
|
||||
forcedelete test.db-oal rbu.db
|
||||
reset_db
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Test that for an RBU to be applied, no corruption results if the
|
||||
# affinities on the source and target table do not match.
|
||||
#
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE x1(a INTEGER PRIMARY KEY, b TEXT, c REAL);
|
||||
CREATE INDEX i1 ON x1(b, c);
|
||||
} {}
|
||||
|
||||
do_test 1.1 {
|
||||
sqlite3 db2 rbu.db
|
||||
db2 eval {
|
||||
CREATE TABLE data_x1(a, b, c, rbu_control);
|
||||
INSERT INTO data_x1 VALUES(1, '123', '123', 0);
|
||||
INSERT INTO data_x1 VALUES(2, 123, 123, 0);
|
||||
}
|
||||
db2 close
|
||||
run_rbu test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 1.2 {
|
||||
PRAGMA integrity_check;
|
||||
} {ok}
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Test that NULL values may not be inserted into INTEGER PRIMARY KEY
|
||||
# columns.
|
||||
#
|
||||
forcedelete rbu.db
|
||||
reset_db
|
||||
|
||||
do_execsql_test 2.0 {
|
||||
CREATE TABLE x1(a INTEGER PRIMARY KEY, b TEXT, c REAL);
|
||||
CREATE INDEX i1 ON x1(b, c);
|
||||
} {}
|
||||
|
||||
foreach {tn rbudb} {
|
||||
1 {
|
||||
CREATE TABLE data_x1(a, b, c, rbu_control);
|
||||
INSERT INTO data_x1 VALUES(NULL, 'a', 'b', 0);
|
||||
}
|
||||
|
||||
2 {
|
||||
CREATE TABLE data_x1(c, b, a, rbu_control);
|
||||
INSERT INTO data_x1 VALUES('b', 'a', NULL, 0);
|
||||
}
|
||||
} {
|
||||
do_test 2.$tn.1 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 db2 rbu.db
|
||||
db2 eval $rbudb
|
||||
db2 close
|
||||
list [catch { run_rbu test.db rbu.db } msg] $msg
|
||||
} {1 {SQLITE_MISMATCH - datatype mismatch}}
|
||||
|
||||
do_execsql_test 2.1.2 {
|
||||
PRAGMA integrity_check;
|
||||
} {ok}
|
||||
}
|
||||
|
||||
#--------------------------------------------------------------------
|
||||
# Test that missing columns are detected.
|
||||
#
|
||||
forcedelete rbu.db
|
||||
reset_db
|
||||
|
||||
do_execsql_test 2.0 {
|
||||
CREATE TABLE x1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON x1(b, c);
|
||||
} {}
|
||||
|
||||
do_test 2.1 {
|
||||
sqlite3 db2 rbu.db
|
||||
db2 eval {
|
||||
CREATE TABLE data_x1(a, b, rbu_control);
|
||||
INSERT INTO data_x1 VALUES(1, 'a', 0);
|
||||
}
|
||||
db2 close
|
||||
list [catch { run_rbu test.db rbu.db } msg] $msg
|
||||
} {1 {SQLITE_ERROR - column missing from data_x1: c}}
|
||||
|
||||
do_execsql_test 2.2 {
|
||||
PRAGMA integrity_check;
|
||||
} {ok}
|
||||
|
||||
# Also extra columns.
|
||||
#
|
||||
do_execsql_test 2.3 {
|
||||
CREATE TABLE x2(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i2 ON x2(b, c);
|
||||
} {}
|
||||
|
||||
do_test 2.4 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 db2 rbu.db
|
||||
db2 eval {
|
||||
CREATE TABLE data_x2(a, b, c, d, rbu_control);
|
||||
INSERT INTO data_x2 VALUES(1, 'a', 2, 3, 0);
|
||||
}
|
||||
db2 close
|
||||
list [catch { run_rbu test.db rbu.db } msg] $msg
|
||||
} {1 SQLITE_ERROR}
|
||||
|
||||
do_execsql_test 2.5 {
|
||||
PRAGMA integrity_check;
|
||||
} {ok}
|
||||
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that sqlite3rbu_create_vfs() returns an error if the requested
|
||||
# parent VFS is unknown.
|
||||
#
|
||||
# And that nothing disasterous happens if a VFS name passed to
|
||||
# sqlite3rbu_destroy_vfs() is unknown or not an RBU vfs.
|
||||
#
|
||||
do_test 3.1 {
|
||||
list [catch {sqlite3rbu_create_vfs xyz nosuchparent} msg] $msg
|
||||
} {1 SQLITE_NOTFOUND}
|
||||
|
||||
do_test 3.2 {
|
||||
sqlite3rbu_destroy_vfs nosuchvfs
|
||||
sqlite3rbu_destroy_vfs unix
|
||||
sqlite3rbu_destroy_vfs win32
|
||||
} {}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that it is an error to specify an explicit VFS that does not
|
||||
# include rbu VFS functionality.
|
||||
#
|
||||
do_test 4.1 {
|
||||
testvfs tvfs
|
||||
sqlite3rbu rbu file:test.db?vfs=tvfs rbu.db
|
||||
list [catch { rbu step } msg] $msg
|
||||
} {0 SQLITE_ERROR}
|
||||
do_test 4.2 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_ERROR - rbu vfs not found}}
|
||||
tvfs delete
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test a large rbu update to ensure that wal_autocheckpoint does not get
|
||||
# in the way.
|
||||
#
|
||||
forcedelete rbu.db
|
||||
reset_db
|
||||
do_execsql_test 5.1 {
|
||||
CREATE TABLE x1(a, b, c, PRIMARY KEY(a)) WITHOUT ROWID;
|
||||
CREATE INDEX i1 ON x1(a);
|
||||
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
CREATE TABLE rbu.data_x1(a, b, c, rbu_control);
|
||||
WITH s(a, b, c) AS (
|
||||
SELECT randomblob(300), randomblob(300), 1
|
||||
UNION ALL
|
||||
SELECT randomblob(300), randomblob(300), c+1 FROM s WHERE c<2000
|
||||
)
|
||||
INSERT INTO data_x1 SELECT a, b, c, 0 FROM s;
|
||||
}
|
||||
|
||||
do_test 5.2 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while {[rbu step]=="SQLITE_OK" && [file exists test.db-wal]==0} {}
|
||||
rbu close
|
||||
} {SQLITE_OK}
|
||||
|
||||
do_test 5.3 {
|
||||
expr {[file size test.db-wal] > (1024 * 1200)}
|
||||
} 1
|
||||
|
||||
do_test 6.1 { sqlite3rbu_internal_test } {}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,303 @@
|
||||
# 2014 August 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
# Test some properties of the pager_rbu_mode and rbu_mode pragmas.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbu5
|
||||
|
||||
|
||||
# Return a list of the primary key columns for table $tbl in the database
|
||||
# opened by database handle $db.
|
||||
#
|
||||
proc pkcols {db tbl} {
|
||||
set ret [list]
|
||||
$db eval "PRAGMA table_info = '$tbl'" {
|
||||
if {$pk} { lappend ret $name }
|
||||
}
|
||||
return $ret
|
||||
}
|
||||
|
||||
# Return a list of all columns for table $tbl in the database opened by
|
||||
# database handle $db.
|
||||
#
|
||||
proc allcols {db tbl} {
|
||||
set ret [list]
|
||||
$db eval "PRAGMA table_info = '$tbl'" {
|
||||
lappend ret $name
|
||||
}
|
||||
return $ret
|
||||
}
|
||||
|
||||
# Return a checksum on all tables and data in the main database attached
|
||||
# to database handle $db. It is possible to add indexes without changing
|
||||
# the checksum.
|
||||
#
|
||||
proc datacksum {db} {
|
||||
|
||||
$db eval { SELECT name FROM sqlite_master WHERE type='table' } {
|
||||
append txt $name
|
||||
set cols [list]
|
||||
set order [list]
|
||||
set cnt 0
|
||||
$db eval "PRAGMA table_info = $name" x {
|
||||
lappend cols "quote($x(name))"
|
||||
lappend order [incr cnt]
|
||||
}
|
||||
set cols [join $cols ,]
|
||||
set order [join $order ,]
|
||||
append txt [$db eval "SELECT $cols FROM $name ORDER BY $order"]
|
||||
}
|
||||
return "[string length $txt]-[md5 $txt]"
|
||||
}
|
||||
|
||||
proc ucontrol {args} {
|
||||
set ret ""
|
||||
foreach a $args {
|
||||
if {$a} {
|
||||
append ret .
|
||||
} else {
|
||||
append ret x
|
||||
}
|
||||
}
|
||||
return $ret
|
||||
}
|
||||
|
||||
# Argument $target is the name of an SQLite database file. $sql is an SQL
|
||||
# script containing INSERT, UPDATE and DELETE statements to execute against
|
||||
# it. This command creates an RBU update database in file $rbu that has
|
||||
# the same effect as the script. The target database is not modified by
|
||||
# this command.
|
||||
#
|
||||
proc generate_rbu_db {target rbu sql} {
|
||||
|
||||
forcedelete $rbu
|
||||
forcecopy $target copy.db
|
||||
|
||||
# Evaluate the SQL script to modify the contents of copy.db.
|
||||
#
|
||||
sqlite3 dbRbu copy.db
|
||||
dbRbu eval $sql
|
||||
|
||||
dbRbu function ucontrol ucontrol
|
||||
|
||||
# Evaluate the SQL script to modify the contents of copy.db.
|
||||
set ret [datacksum dbRbu]
|
||||
|
||||
dbRbu eval { ATTACH $rbu AS rbu }
|
||||
dbRbu eval { ATTACH $target AS orig }
|
||||
|
||||
dbRbu eval { SELECT name AS tbl FROM sqlite_master WHERE type = 'table' } {
|
||||
set pk [pkcols dbRbu $tbl]
|
||||
set cols [allcols dbRbu $tbl]
|
||||
|
||||
# A WHERE clause to test that the PK columns match.
|
||||
#
|
||||
set where [list]
|
||||
foreach c $pk { lappend where "main.$tbl.$c IS orig.$tbl.$c" }
|
||||
set where [join $where " AND "]
|
||||
|
||||
# A WHERE clause to test that all columns match.
|
||||
#
|
||||
set where2 [list]
|
||||
foreach c $cols { lappend where2 "main.$tbl.$c IS orig.$tbl.$c" }
|
||||
set ucontrol "ucontrol([join $where2 ,])"
|
||||
set where2 [join $where2 " AND "]
|
||||
|
||||
# Create a data_xxx table in the RBU update database.
|
||||
dbRbu eval "
|
||||
CREATE TABLE rbu.data_$tbl AS SELECT *, '' AS rbu_control
|
||||
FROM main.$tbl LIMIT 0
|
||||
"
|
||||
|
||||
# Find all new rows INSERTed by the script.
|
||||
dbRbu eval "
|
||||
INSERT INTO rbu.data_$tbl
|
||||
SELECT *, 0 AS rbu_control FROM main.$tbl
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1 FROM orig.$tbl WHERE $where
|
||||
)
|
||||
"
|
||||
|
||||
# Find all old rows DELETEd by the script.
|
||||
dbRbu eval "
|
||||
INSERT INTO rbu.data_$tbl
|
||||
SELECT *, 1 AS rbu_control FROM orig.$tbl
|
||||
WHERE NOT EXISTS (
|
||||
SELECT 1 FROM main.$tbl WHERE $where
|
||||
)
|
||||
"
|
||||
|
||||
# Find all rows UPDATEd by the script.
|
||||
set origcols [list]
|
||||
foreach c $cols { lappend origcols "main.$tbl.$c" }
|
||||
set origcols [join $origcols ,]
|
||||
dbRbu eval "
|
||||
INSERT INTO rbu.data_$tbl
|
||||
SELECT $origcols, $ucontrol AS rbu_control
|
||||
FROM orig.$tbl, main.$tbl
|
||||
WHERE $where AND NOT ($where2)
|
||||
"
|
||||
|
||||
}
|
||||
|
||||
dbRbu close
|
||||
forcedelete copy.db
|
||||
|
||||
return $ret
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE TABLE t2(x, y, z, PRIMARY KEY(y, z)) WITHOUT ROWID;
|
||||
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(2, 4, 6);
|
||||
INSERT INTO t1 VALUES(3, 6, 9);
|
||||
|
||||
INSERT INTO t2 VALUES(1, 2, 3);
|
||||
INSERT INTO t2 VALUES(2, 4, 6);
|
||||
INSERT INTO t2 VALUES(3, 6, 9);
|
||||
}
|
||||
db close
|
||||
|
||||
set cksum [generate_rbu_db test.db rbu.db {
|
||||
INSERT INTO t1 VALUES(4, 8, 12);
|
||||
DELETE FROM t1 WHERE a = 2;
|
||||
UPDATE t1 SET c = 15 WHERE a=3;
|
||||
|
||||
INSERT INTO t2 VALUES(4, 8, 12);
|
||||
DELETE FROM t2 WHERE x = 2;
|
||||
UPDATE t2 SET x = 15 WHERE z=9;
|
||||
}]
|
||||
|
||||
foreach {tn idx} {
|
||||
1 {
|
||||
}
|
||||
2 {
|
||||
CREATE INDEX i1 ON t1(a, b, c);
|
||||
CREATE INDEX i2 ON t2(x, y, z);
|
||||
}
|
||||
} {
|
||||
foreach cmd {run step} {
|
||||
forcecopy test.db test.db2
|
||||
forcecopy rbu.db rbu.db2
|
||||
|
||||
sqlite3 db test.db2
|
||||
db eval $idx
|
||||
|
||||
do_test 1.$tn.$cmd.1 {
|
||||
${cmd}_rbu test.db2 rbu.db2
|
||||
datacksum db
|
||||
} $cksum
|
||||
|
||||
do_test 1.$tn.$cmd.2 {
|
||||
db eval { PRAGMA integrity_check }
|
||||
} {ok}
|
||||
|
||||
db close
|
||||
}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 2.0 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d, e);
|
||||
INSERT INTO t1 VALUES(-750250,'fyetckfaagjkzqjx',-185831,X'FEAD',444258.29);
|
||||
INSERT INTO t1 VALUES(649081,NULL,X'7DF25BF78778',-342324.63,'akvspktocwozo');
|
||||
INSERT INTO t1 VALUES(-133045,-44822.31,X'',287935,NULL);
|
||||
INSERT INTO t1 VALUES(202132,NULL,X'5399','cujsjtspryqeyovcdpz','m');
|
||||
INSERT INTO t1 VALUES(302910,NULL,'dvdhivtfkaedzhdcnn',-717113.41,688487);
|
||||
INSERT INTO t1 VALUES(-582327,X'7A267A',X'7E6B3CFE5CB9','zacuzilrok',-196478);
|
||||
INSERT INTO t1 VALUES(-190462,X'D1A087E7D68D9578','lsmleti',NULL,-928094);
|
||||
INSERT INTO t1 VALUES(-467665,176344.57,-536684.23,828876.22,X'903E');
|
||||
INSERT INTO t1 VALUES(-629138,632630.29,X'28D6',-774501,X'819BBBFC65');
|
||||
INSERT INTO t1 VALUES(-828110,-54379.24,-881121.44,X'',X'8D5A894F0D');
|
||||
|
||||
CREATE TABLE t2(a PRIMARY KEY, b, c, d, e) WITHOUT ROWID;
|
||||
INSERT INTO t2 VALUES(-65174,X'AC1DBFFE27310F',-194471.08,347988,X'84041BA6F9BDDE86A8');
|
||||
INSERT INTO t2 VALUES('bzbpi',-952693.69,811628.25,NULL,-817434);
|
||||
INSERT INTO t2 VALUES(-643830,NULL,'n',NULL,'dio');
|
||||
INSERT INTO t2 VALUES('rovoenxxj',NULL,'owupbtdcoxxnvg',-119676,X'55431DFA');
|
||||
INSERT INTO t2 VALUES(899770,'jlygdl',X'DBCA4D1A',NULL,-631773);
|
||||
INSERT INTO t2 VALUES(334698.80,NULL,-697585.58,-89277,-817352);
|
||||
INSERT INTO t2 VALUES(X'1A9EB7547A4AAF38','aiprdhkpzdz','anw','szvjbwdvzucybpwwqjt',X'53');
|
||||
INSERT INTO t2 VALUES(713220,NULL,'hfcqhqzjuqplvkum',X'20B076075649DE','fthgpvqdyy');
|
||||
INSERT INTO t2 VALUES(763908,NULL,'xgslzcpvwfknbr',X'75',X'668146');
|
||||
INSERT INTO t2 VALUES(X'E1BA2B6BA27278','wjbpd',NULL,139341,-290086.15);
|
||||
}
|
||||
db close
|
||||
|
||||
set cksum [generate_rbu_db test.db rbu.db {
|
||||
INSERT INTO t2 VALUES(222916.23,'idh',X'472C517405',X'E3',X'7C4F31824669');
|
||||
INSERT INTO t2 VALUES('xcndjwafcoxwxizoktd',-319567.21,NULL,-720906.43,-577170);
|
||||
INSERT INTO t2 VALUES(376369.99,-536058,'yoaiurfqupdscwc',X'29EC8A2542EC3953E9',-740485.22);
|
||||
INSERT INTO t2 VALUES(X'0EFB4DC50693',-175590.83,X'1779E253CAB5B1789E',X'BC6903',NULL);
|
||||
INSERT INTO t2 VALUES(-288299,'hfrp',NULL,528477,730676.77);
|
||||
DELETE FROM t2 WHERE a < -60000;
|
||||
|
||||
UPDATE t2 SET b = 'pgnnaaoflnw' WHERE a = 'bzbpi';
|
||||
UPDATE t2 SET c = -675583 WHERE a = 'rovoenxxj';
|
||||
UPDATE t2 SET d = X'09CDF2B2C241' WHERE a = 713220;
|
||||
|
||||
INSERT INTO t1 VALUES(224938,'bmruycvfznhhnfmgqys','fr',854381,789143);
|
||||
INSERT INTO t1 VALUES(-863931,-1386.26,X'2A058540C2FB5C',NULL,X'F9D5990A');
|
||||
INSERT INTO t1 VALUES(673696,X'97301F0AC5735F44B5',X'440C',227999.92,-709599.79);
|
||||
INSERT INTO t1 VALUES(-243640,NULL,-71718.11,X'1EEFEB38',X'8CC7C55D95E142FBA5');
|
||||
INSERT INTO t1 VALUES(275893,X'',375606.30,X'0AF9EC334711FB',-468194);
|
||||
DELETE FROM t1 WHERE a > 200000;
|
||||
|
||||
UPDATE t1 SET b = 'pgnnaaoflnw' WHERE a = -190462;
|
||||
UPDATE t1 SET c = -675583 WHERE a = -467665;
|
||||
UPDATE t1 SET d = X'09CDF2B2C241' WHERE a = -133045;
|
||||
|
||||
}]
|
||||
|
||||
foreach {tn idx} {
|
||||
1 {
|
||||
}
|
||||
2 {
|
||||
CREATE UNIQUE INDEX i1 ON t1(b, c, d);
|
||||
CREATE UNIQUE INDEX i2 ON t1(d, e, a);
|
||||
CREATE UNIQUE INDEX i3 ON t1(e, d, c, b);
|
||||
|
||||
CREATE UNIQUE INDEX i4 ON t2(b, c, d);
|
||||
CREATE UNIQUE INDEX i5 ON t2(d, e, a);
|
||||
CREATE UNIQUE INDEX i6 ON t2(e, d, c, b);
|
||||
}
|
||||
} {
|
||||
foreach cmd {run step} {
|
||||
forcecopy test.db test.db2
|
||||
forcecopy rbu.db rbu.db2
|
||||
|
||||
sqlite3 db test.db2
|
||||
db eval $idx
|
||||
|
||||
do_test 2.$tn.$cmd.1 {
|
||||
${cmd}_rbu test.db2 rbu.db2
|
||||
datacksum db
|
||||
} $cksum
|
||||
|
||||
do_test 2.$tn.$cmd.2 {
|
||||
db eval { PRAGMA integrity_check }
|
||||
} {ok}
|
||||
|
||||
db close
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,100 @@
|
||||
# 2014 October 21
|
||||
#
|
||||
# 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 contains tests for the RBU module. Specifically, it tests the
|
||||
# outcome of some other client writing to the database while an RBU update
|
||||
# is being applied.
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbu6
|
||||
|
||||
proc setup_test {} {
|
||||
reset_db
|
||||
execsql {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b UNIQUE);
|
||||
CREATE TABLE t2(a INTEGER PRIMARY KEY, b UNIQUE);
|
||||
CREATE TABLE t3(a INTEGER PRIMARY KEY, b UNIQUE);
|
||||
}
|
||||
db close
|
||||
|
||||
forcedelete rbu.db
|
||||
sqlite3 rbu rbu.db
|
||||
rbu eval {
|
||||
CREATE TABLE data_t1(a, b, rbu_control);
|
||||
CREATE TABLE data_t2(a, b, rbu_control);
|
||||
CREATE TABLE data_t3(a, b, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 't1', 0);
|
||||
INSERT INTO data_t2 VALUES(2, 't2', 0);
|
||||
INSERT INTO data_t3 VALUES(3, 't3', 0);
|
||||
}
|
||||
rbu close
|
||||
}
|
||||
|
||||
# Test the outcome of some other client writing the db while the *-oal
|
||||
# file is being generated. Once this has happened, the update cannot be
|
||||
# progressed.
|
||||
#
|
||||
for {set nStep 1} {$nStep < 8} {incr nStep} {
|
||||
do_test 1.$nStep.1 {
|
||||
setup_test
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
for {set i 0} {$i<$nStep} {incr i} {rbu step}
|
||||
|
||||
rbu close
|
||||
sqlite3 db test.db
|
||||
execsql { INSERT INTO t1 VALUES(5, 'hello') }
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_BUSY}
|
||||
do_test 1.$nStep.2 {
|
||||
rbu step
|
||||
} {SQLITE_BUSY}
|
||||
do_test 1.$nStep.3 {
|
||||
list [file exists test.db-oal] [file exists test.db-wal]
|
||||
} {1 0}
|
||||
do_test 1.$nStep.4 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_BUSY - database modified during rbu update}}
|
||||
}
|
||||
|
||||
# Test the outcome of some other client writing the db after the *-oal
|
||||
# file has been copied to the *-wal path. Once this has happened, any
|
||||
# other client writing to the db causes RBU to consider its job finished.
|
||||
#
|
||||
for {set nStep 8} {$nStep < 20} {incr nStep} {
|
||||
do_test 1.$nStep.1 {
|
||||
setup_test
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
for {set i 0} {$i<$nStep} {incr i} {rbu step}
|
||||
rbu close
|
||||
sqlite3 db test.db
|
||||
execsql { INSERT INTO t1 VALUES(5, 'hello') }
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_DONE}
|
||||
do_test 1.$nStep.2 {
|
||||
rbu step
|
||||
} {SQLITE_DONE}
|
||||
do_test 1.$nStep.3 {
|
||||
file exists test.db-oal
|
||||
} {0}
|
||||
do_test 1.$nStep.4 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {0 SQLITE_DONE}
|
||||
|
||||
do_execsql_test 1.$nStep.5 {
|
||||
SELECT * FROM t1;
|
||||
} {1 t1 5 hello}
|
||||
}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,106 @@
|
||||
# 2014 October 21
|
||||
#
|
||||
# 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 contains tests for the RBU module.
|
||||
#
|
||||
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbu7
|
||||
|
||||
# Test index:
|
||||
#
|
||||
# 1.*: That affinities are correctly applied to values within the
|
||||
# RBU database.
|
||||
#
|
||||
# 2.*: Tests for multi-column primary keys.
|
||||
#
|
||||
|
||||
do_test 1.0 {
|
||||
execsql {
|
||||
CREATE TABLE t1(a INT PRIMARY KEY, b) WITHOUT ROWID;
|
||||
INSERT INTO t1 VALUES(1, 'abc');
|
||||
INSERT INTO t1 VALUES(2, 'def');
|
||||
}
|
||||
|
||||
forcedelete rbu.db
|
||||
sqlite3 rbu rbu.db
|
||||
rbu eval {
|
||||
CREATE TABLE data_t1(a, b, rbu_control);
|
||||
INSERT INTO data_t1 VALUES('1', NULL, 1);
|
||||
}
|
||||
rbu close
|
||||
} {}
|
||||
|
||||
do_test 1.1 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while { [rbu step]=="SQLITE_OK" } {}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
sqlite3 db test.db
|
||||
do_execsql_test 1.2 {
|
||||
SELECT * FROM t1
|
||||
} {2 def}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
foreach {tn tbl} {
|
||||
1 { CREATE TABLE t1(a, b, c, PRIMARY KEY(a, b)) WITHOUT ROWID }
|
||||
2 { CREATE TABLE t1(a, b, c, PRIMARY KEY(a, b)) }
|
||||
} {
|
||||
reset_db
|
||||
|
||||
execsql $tbl
|
||||
do_execsql_test 2.$tn.1 {
|
||||
CREATE INDEX t1c ON t1(c);
|
||||
INSERT INTO t1 VALUES(1, 1, 'a');
|
||||
INSERT INTO t1 VALUES(1, 2, 'b');
|
||||
INSERT INTO t1 VALUES(2, 1, 'c');
|
||||
INSERT INTO t1 VALUES(2, 2, 'd');
|
||||
}
|
||||
|
||||
do_test 2.$tn.2 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 rbu rbu.db
|
||||
execsql {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(3, 1, 'e', 0);
|
||||
INSERT INTO data_t1 VALUES(3, 2, 'f', 0);
|
||||
INSERT INTO data_t1 VALUES(1, 2, NULL, 1);
|
||||
INSERT INTO data_t1 VALUES(2, 1, 'X', '..x');
|
||||
} rbu
|
||||
rbu close
|
||||
} {}
|
||||
|
||||
do_test 2.$tn.3 {
|
||||
set rc "SQLITE_OK"
|
||||
while {$rc == "SQLITE_OK"} {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
set rc [rbu close]
|
||||
}
|
||||
set rc
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 2.$tn.1 {
|
||||
SELECT * FROM t1 ORDER BY a, b
|
||||
} {
|
||||
1 1 a
|
||||
2 1 X
|
||||
2 2 d
|
||||
3 1 e
|
||||
3 2 f
|
||||
}
|
||||
}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,72 @@
|
||||
# 2014 November 20
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
# Test the rbu_delta() feature.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbu8
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(x, y PRIMARY KEY, z);
|
||||
INSERT INTO t1 VALUES(NULL, 1, 'one');
|
||||
INSERT INTO t1 VALUES(NULL, 2, 'two');
|
||||
INSERT INTO t1 VALUES(NULL, 3, 'three');
|
||||
CREATE INDEX i1z ON t1(z, x);
|
||||
}
|
||||
|
||||
do_test 1.1 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 db2 rbu.db
|
||||
db2 eval {
|
||||
CREATE TABLE data_t1(x, y, z, rbu_control);
|
||||
INSERT INTO data_t1 VALUES('a', 1, '_i' , 'x.d');
|
||||
INSERT INTO data_t1 VALUES('b', 2, 2 , '..x');
|
||||
INSERT INTO data_t1 VALUES('_iii', 3, '-III' , 'd.d');
|
||||
}
|
||||
db2 close
|
||||
} {}
|
||||
|
||||
do_test 1.2.1 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_ERROR}
|
||||
do_test 1.2.2 {
|
||||
list [catch {rbu close} msg] $msg
|
||||
} {1 {SQLITE_ERROR - no such function: rbu_delta}}
|
||||
|
||||
proc rbu_delta {orig new} {
|
||||
return "${orig}${new}"
|
||||
}
|
||||
|
||||
do_test 1.3.1 {
|
||||
while 1 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu create_rbu_delta
|
||||
set rc [rbu step]
|
||||
if {$rc != "SQLITE_OK"} break
|
||||
rbu close
|
||||
}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 1.3.2 {
|
||||
SELECT * FROM t1
|
||||
} {
|
||||
a 1 one_i
|
||||
{} 2 2
|
||||
_iii 3 three-III
|
||||
}
|
||||
integrity_check 1.3.3
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,125 @@
|
||||
# 2014 November 21
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
# Test RBU with virtual tables. And tables with no PRIMARY KEY declarations.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbu9
|
||||
|
||||
ifcapable !fts3 {
|
||||
finish_test
|
||||
return
|
||||
}
|
||||
|
||||
do_execsql_test 1.1 {
|
||||
CREATE VIRTUAL TABLE f1 USING fts4(a, b, c);
|
||||
INSERT INTO f1(rowid, a, b, c) VALUES(11, 'a', 'b', 'c');
|
||||
INSERT INTO f1(rowid, a, b, c) VALUES(12, 'd', 'e', 'f');
|
||||
INSERT INTO f1(rowid, a, b, c) VALUES(13, 'g', 'h', 'i');
|
||||
}
|
||||
|
||||
do_test 1.1 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 db2 rbu.db
|
||||
db2 eval {
|
||||
CREATE TABLE data_f1(rbu_rowid, a, b, c, rbu_control);
|
||||
INSERT INTO data_f1 VALUES(14, 'x', 'y', 'z', 0); -- INSERT
|
||||
INSERT INTO data_f1 VALUES(11, NULL, NULL, NULL, 1); -- DELETE
|
||||
INSERT INTO data_f1 VALUES(13, NULL, NULL, 'X', '..x'); -- UPDATE
|
||||
}
|
||||
db2 close
|
||||
} {}
|
||||
|
||||
do_test 1.2.1 {
|
||||
while 1 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
set rc [rbu step]
|
||||
if {$rc != "SQLITE_OK"} break
|
||||
rbu close
|
||||
}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 1.2.2 { SELECT rowid, * FROM f1 } {
|
||||
12 d e f
|
||||
13 g h X
|
||||
14 x y z
|
||||
}
|
||||
do_execsql_test 1.2.3 { INSERT INTO f1(f1) VALUES('integrity-check') }
|
||||
integrity_check 1.2.4
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Tables with no PK declaration.
|
||||
#
|
||||
|
||||
# Run the RBU in file $rbu on target database $target until completion.
|
||||
#
|
||||
proc run_rbu {target rbu} {
|
||||
sqlite3rbu rbu $target $rbu
|
||||
while { [rbu step]=="SQLITE_OK" } {}
|
||||
rbu close
|
||||
}
|
||||
|
||||
foreach {tn idx} {
|
||||
1 { }
|
||||
2 {
|
||||
CREATE INDEX i1 ON t1(a);
|
||||
}
|
||||
3 {
|
||||
CREATE INDEX i1 ON t1(b, c);
|
||||
CREATE INDEX i2 ON t1(c, b);
|
||||
CREATE INDEX i3 ON t1(a, a, a, b, b, b, c, c, c);
|
||||
}
|
||||
} {
|
||||
|
||||
reset_db
|
||||
do_execsql_test 2.$tn.1 {
|
||||
CREATE TABLE t1(a, b, c);
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
INSERT INTO t1(rowid, a, b, c) VALUES(-1, 'a', 'b', 'c');
|
||||
INSERT INTO t1(rowid, a, b, c) VALUES(-2, 'd', 'e', 'f');
|
||||
}
|
||||
|
||||
db eval $idx
|
||||
|
||||
do_test 2.$tn.2 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 db2 rbu.db
|
||||
db2 eval {
|
||||
CREATE TABLE data_t1(rbu_rowid, a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(3, 'x', 'y', 'z', 0);
|
||||
INSERT INTO data_t1 VALUES(NULL, 'X', 'Y', 'Z', 0);
|
||||
INSERT INTO data_t1 VALUES('1', NULL, NULL, NULL, 1);
|
||||
INSERT INTO data_t1 VALUES(-2, NULL, NULL, 'fff', '..x');
|
||||
}
|
||||
db2 close
|
||||
} {}
|
||||
|
||||
run_rbu test.db rbu.db
|
||||
|
||||
do_execsql_test 2.$tn.3 {
|
||||
SELECT rowid, a, b, c FROM t1 ORDER BY rowid;
|
||||
} {
|
||||
-2 d e fff
|
||||
-1 a b c
|
||||
2 4 5 6
|
||||
3 x y z
|
||||
4 X Y Z
|
||||
}
|
||||
|
||||
integrity_check 2.$tn.4
|
||||
}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,80 @@
|
||||
# 2014 August 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 contains tests for the RBU module. More specifically, it
|
||||
# contains tests to ensure that it is an error to attempt to update
|
||||
# a wal mode database via RBU.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbuA
|
||||
|
||||
set db_sql {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
}
|
||||
set rbu_sql {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 2, 3, 0);
|
||||
INSERT INTO data_t1 VALUES(4, 5, 6, 0);
|
||||
INSERT INTO data_t1 VALUES(7, 8, 9, 0);
|
||||
}
|
||||
|
||||
do_test 1.0 {
|
||||
db close
|
||||
forcedelete test.db rbu.db
|
||||
|
||||
sqlite3 db test.db
|
||||
db eval $db_sql
|
||||
db eval { PRAGMA journal_mode = wal }
|
||||
db close
|
||||
|
||||
sqlite3 db rbu.db
|
||||
db eval $rbu_sql
|
||||
db close
|
||||
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_ERROR}
|
||||
do_test 1.1 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_ERROR - cannot update wal mode database}}
|
||||
|
||||
do_test 2.0 {
|
||||
forcedelete test.db rbu.db
|
||||
|
||||
sqlite3 db test.db
|
||||
db eval $db_sql
|
||||
db close
|
||||
|
||||
sqlite3 db rbu.db
|
||||
db eval $rbu_sql
|
||||
db close
|
||||
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
rbu close
|
||||
} {SQLITE_OK}
|
||||
|
||||
do_test 2.1 {
|
||||
sqlite3 db test.db
|
||||
db eval {PRAGMA journal_mode = wal}
|
||||
db close
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_ERROR}
|
||||
|
||||
do_test 2.2 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_ERROR - cannot update wal mode database}}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,62 @@
|
||||
# 2014 August 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbuB
|
||||
|
||||
db close
|
||||
sqlite3_shutdown
|
||||
test_sqlite3_log xLog
|
||||
reset_db
|
||||
|
||||
proc xLog {args} { }
|
||||
|
||||
set db_sql {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
}
|
||||
set rbu_sql {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 2, 3, 0);
|
||||
INSERT INTO data_t1 VALUES(4, 5, 6, 0);
|
||||
INSERT INTO data_t1 VALUES(7, 8, 9, 0);
|
||||
}
|
||||
|
||||
do_test 1.1 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 rbu rbu.db
|
||||
rbu eval $rbu_sql
|
||||
rbu close
|
||||
|
||||
db eval $db_sql
|
||||
} {}
|
||||
|
||||
set ::errlog [list]
|
||||
proc xLog {err msg} { lappend ::errlog $err }
|
||||
do_test 1.2 {
|
||||
run_rbu test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 1.3 {
|
||||
set ::errlog
|
||||
} {SQLITE_NOTICE_RECOVER_WAL SQLITE_NOTICE_RBU}
|
||||
|
||||
do_execsql_test 1.4 {
|
||||
SELECT * FROM t1
|
||||
} {1 2 3 4 5 6 7 8 9}
|
||||
|
||||
db close
|
||||
sqlite3_shutdown
|
||||
test_sqlite3_log
|
||||
sqlite3_initialize
|
||||
finish_test
|
||||
@@ -0,0 +1,142 @@
|
||||
# 2016 March 7
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
# Tests for RBU focused on the REPLACE operation (rbu_control column
|
||||
# contains integer value 2).
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbuC
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# This test is actually of an UPDATE directive. Just to establish that
|
||||
# these work with UNIQUE indexes before preceding to REPLACE.
|
||||
#
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(i INTEGER PRIMARY KEY, a, b, c UNIQUE);
|
||||
INSERT INTO t1 VALUES(1, 'a', 'b', 'c');
|
||||
}
|
||||
|
||||
forcedelete rbu.db
|
||||
do_execsql_test 1.1 {
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
CREATE TABLE rbu.data_t1(i, a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 'a', 'b', 'c', '.xxx');
|
||||
}
|
||||
|
||||
do_test 1.2 {
|
||||
step_rbu test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 1.3 {
|
||||
SELECT * FROM t1
|
||||
} {
|
||||
1 a b c
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
foreach {tn schema} {
|
||||
1 {
|
||||
CREATE TABLE t1(i INTEGER PRIMARY KEY, a, b, c UNIQUE);
|
||||
CREATE INDEX t1a ON t1(a);
|
||||
}
|
||||
2 {
|
||||
CREATE TABLE t1(i PRIMARY KEY, a, b, c UNIQUE);
|
||||
CREATE INDEX t1a ON t1(a);
|
||||
}
|
||||
3 {
|
||||
CREATE TABLE t1(i PRIMARY KEY, a, b, c UNIQUE) WITHOUT ROWID;
|
||||
CREATE INDEX t1a ON t1(a);
|
||||
}
|
||||
} {
|
||||
reset_db
|
||||
forcedelete rbu.db
|
||||
execsql $schema
|
||||
|
||||
do_execsql_test 2.$tn.0 {
|
||||
INSERT INTO t1 VALUES(1, 'a', 'b', 'c');
|
||||
INSERT INTO t1 VALUES(2, 'b', 'c', 'd');
|
||||
INSERT INTO t1 VALUES(3, 'c', 'd', 'e');
|
||||
}
|
||||
|
||||
do_execsql_test 2.$tn.1 {
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
CREATE TABLE rbu.data_t1(i, a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 1, 2, 3, 2);
|
||||
INSERT INTO data_t1 VALUES(3, 'c', 'd', 'e', 2);
|
||||
INSERT INTO data_t1 VALUES(4, 'd', 'e', 'f', 2);
|
||||
}
|
||||
|
||||
do_test 2.$tn.2 {
|
||||
step_rbu test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 2.$tn.3 {
|
||||
SELECT * FROM t1 ORDER BY i
|
||||
} {
|
||||
1 1 2 3
|
||||
2 b c d
|
||||
3 c d e
|
||||
4 d e f
|
||||
}
|
||||
|
||||
integrity_check 2.$tn.4
|
||||
}
|
||||
|
||||
foreach {tn schema} {
|
||||
1 {
|
||||
CREATE TABLE t1(a, b, c UNIQUE);
|
||||
CREATE INDEX t1a ON t1(a);
|
||||
}
|
||||
|
||||
2 {
|
||||
CREATE VIRTUAL TABLE t1 USING fts5(a, b, c);
|
||||
}
|
||||
} {
|
||||
if {$tn==2} { ifcapable !fts5 break }
|
||||
reset_db
|
||||
forcedelete rbu.db
|
||||
execsql $schema
|
||||
|
||||
do_execsql_test 3.$tn.0 {
|
||||
INSERT INTO t1 VALUES('a', 'b', 'c');
|
||||
INSERT INTO t1 VALUES('b', 'c', 'd');
|
||||
INSERT INTO t1 VALUES('c', 'd', 'e');
|
||||
}
|
||||
|
||||
do_execsql_test 3.$tn.1 {
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
CREATE TABLE rbu.data_t1(rbu_rowid, a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 1, 2, 3, 2);
|
||||
INSERT INTO data_t1 VALUES(3, 'c', 'd', 'e', 2);
|
||||
INSERT INTO data_t1 VALUES(4, 'd', 'e', 'f', 2);
|
||||
}
|
||||
|
||||
do_test 3.$tn.2 {
|
||||
step_rbu test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 3.$tn.3 {
|
||||
SELECT rowid, * FROM t1 ORDER BY 1
|
||||
} {
|
||||
1 1 2 3
|
||||
2 b c d
|
||||
3 c d e
|
||||
4 d e f
|
||||
}
|
||||
|
||||
integrity_check 3.$tn.4
|
||||
}
|
||||
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,120 @@
|
||||
# 2015 Aug 8
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
if {![info exists testdir]} {
|
||||
set testdir [file join [file dirname [info script]] .. .. test]
|
||||
}
|
||||
source $testdir/tester.tcl
|
||||
|
||||
proc if_no_rbu_support {tcl} {
|
||||
set bOk 1
|
||||
ifcapable !rbu { set bOk 0 }
|
||||
if {[permutation]=="journaltest"} { set bOk 0 }
|
||||
if {$bOk==0} {
|
||||
set c [catch {uplevel 1 $tcl} r]
|
||||
return -code $c $r
|
||||
}
|
||||
}
|
||||
|
||||
proc check_prestep_state {target state} {
|
||||
set oal_exists [file exists $target-oal]
|
||||
set wal_exists [file exists $target-wal]
|
||||
set progress [rbu progress]
|
||||
|
||||
if {($progress==0 && $state!="oal" && $state!="done")
|
||||
|| ($oal_exists && $wal_exists)
|
||||
|| ($progress>0 && $state=="oal" && (!$oal_exists || $wal_exists))
|
||||
|| ($state=="move" && (!$oal_exists || $wal_exists))
|
||||
|| ($state=="checkpoint" && ($oal_exists || !$wal_exists))
|
||||
|| ($state=="done" && ($oal_exists && $progress!=0))
|
||||
} {
|
||||
error "B: state=$state progress=$progress oal=$oal_exists wal=$wal_exists"
|
||||
}
|
||||
}
|
||||
|
||||
proc check_poststep_state {rc target state} {
|
||||
if {$rc=="SQLITE_OK" || $rc=="SQLITE_DONE"} {
|
||||
set oal_exists [file exists $target-oal]
|
||||
set wal_exists [file exists $target-wal]
|
||||
if {$state=="move" && ($oal_exists || !$wal_exists)} {
|
||||
error "A: state=$state progress=$progress oal=$oal_exists wal=$wal_exists"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# Run the RBU in file $rbu on target database $target until completion.
|
||||
#
|
||||
proc run_rbu {target rbu} {
|
||||
sqlite3rbu rbu $target $rbu
|
||||
while 1 {
|
||||
set state [rbu state]
|
||||
|
||||
check_prestep_state $target $state
|
||||
set rc [rbu step]
|
||||
check_poststep_state $rc $target $state
|
||||
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
}
|
||||
rbu close
|
||||
}
|
||||
|
||||
proc step_rbu {target rbu} {
|
||||
while 1 {
|
||||
sqlite3rbu rbu $target $rbu
|
||||
set state [rbu state]
|
||||
check_prestep_state $target $state
|
||||
set rc [rbu step]
|
||||
check_poststep_state $rc $target $state
|
||||
rbu close
|
||||
if {$rc != "SQLITE_OK"} break
|
||||
}
|
||||
set rc
|
||||
}
|
||||
|
||||
proc step_rbu_legacy {target rbu} {
|
||||
while 1 {
|
||||
sqlite3rbu rbu $target $rbu
|
||||
set state [rbu state]
|
||||
check_prestep_state $target $state
|
||||
set rc [rbu step]
|
||||
check_poststep_state $rc $target $state
|
||||
rbu close
|
||||
if {$rc != "SQLITE_OK"} break
|
||||
sqlite3 tmpdb $rbu
|
||||
tmpdb eval { DELETE FROM rbu_state WHERE k==10 }
|
||||
tmpdb close
|
||||
}
|
||||
set rc
|
||||
}
|
||||
|
||||
proc do_rbu_vacuum_test {tn step {statedb state.db}} {
|
||||
forcedelete $statedb
|
||||
if {$statedb=="" && $step==1} breakpoint
|
||||
uplevel [list do_test $tn.1 [string map [list %state% $statedb %step% $step] {
|
||||
if {%step%==0} { sqlite3rbu_vacuum rbu test.db {%state%}}
|
||||
while 1 {
|
||||
if {%step%==1} { sqlite3rbu_vacuum rbu test.db {%state%}}
|
||||
set state [rbu state]
|
||||
check_prestep_state test.db $state
|
||||
set rc [rbu step]
|
||||
check_poststep_state $rc test.db $state
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
if {%step%==1} { rbu close }
|
||||
}
|
||||
rbu close
|
||||
}] {SQLITE_DONE}]
|
||||
|
||||
uplevel [list do_execsql_test $tn.2 {
|
||||
PRAGMA integrity_check
|
||||
} ok]
|
||||
}
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
# 2014 August 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
ifcapable !rbu { finish_test ; return }
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbubusy
|
||||
|
||||
db close
|
||||
sqlite3_shutdown
|
||||
test_sqlite3_log xLog
|
||||
reset_db
|
||||
|
||||
set db_sql {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
INSERT INTO t1 VALUES(1000, 2000, 3000);
|
||||
}
|
||||
|
||||
set rbu_sql {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 2, 3, 0);
|
||||
INSERT INTO data_t1 VALUES(4, 5, 6, 0);
|
||||
INSERT INTO data_t1 VALUES(7, 8, 9, 0);
|
||||
}
|
||||
|
||||
do_test 1.1 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 rbu rbu.db
|
||||
rbu eval $rbu_sql
|
||||
rbu close
|
||||
|
||||
db eval $db_sql
|
||||
} {}
|
||||
|
||||
do_execsql_test 1.2 {
|
||||
BEGIN;
|
||||
SELECT * FROM t1
|
||||
} {1000 2000 3000}
|
||||
|
||||
do_test 1.3 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
} {SQLITE_OK}
|
||||
|
||||
do_test 1.4 {
|
||||
while 1 {
|
||||
set rc [rbu step]
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
}
|
||||
set rc
|
||||
} {SQLITE_BUSY}
|
||||
|
||||
do_test 1.5 {
|
||||
rbu step
|
||||
} {SQLITE_BUSY}
|
||||
|
||||
do_test 1.6 {
|
||||
db eval COMMIT
|
||||
rbu step
|
||||
} {SQLITE_BUSY}
|
||||
catch { rbu close }
|
||||
|
||||
do_test 1.7 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while 1 {
|
||||
set rc [rbu step]
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
}
|
||||
set rc
|
||||
} {SQLITE_DONE}
|
||||
|
||||
rbu close
|
||||
|
||||
db close
|
||||
sqlite3_shutdown
|
||||
test_sqlite3_log
|
||||
sqlite3_initialize
|
||||
finish_test
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
# 2018 March 22
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbucollate
|
||||
|
||||
ifcapable !icu_collations {
|
||||
finish_test
|
||||
return
|
||||
}
|
||||
|
||||
# Create a simple RBU database. That expects to write to a table:
|
||||
#
|
||||
# CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
#
|
||||
proc create_rbu1 {filename} {
|
||||
forcedelete $filename
|
||||
sqlite3 rbu1 $filename
|
||||
rbu1 eval {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES('a', 'one', 1, 0);
|
||||
INSERT INTO data_t1 VALUES('b', 'two', 2, 0);
|
||||
INSERT INTO data_t1 VALUES('c', 'three', 3, 0);
|
||||
}
|
||||
rbu1 close
|
||||
return $filename
|
||||
}
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
SELECT icu_load_collation('en_US', 'my-collate');
|
||||
CREATE TABLE t1(a COLLATE "my-collate" PRIMARY KEY, b, c);
|
||||
} {{}}
|
||||
|
||||
do_test 1.2 {
|
||||
create_rbu1 testrbu.db
|
||||
sqlite3rbu rbu test.db testrbu.db
|
||||
rbu dbMain_eval { SELECT icu_load_collation('en_US', 'my-collate') }
|
||||
rbu dbRbu_eval { SELECT icu_load_collation('en_US', 'my-collate') }
|
||||
while 1 {
|
||||
set rc [rbu step]
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
}
|
||||
rbu close
|
||||
db eval { SELECT * FROM t1 }
|
||||
} {a one 1 b two 2 c three 3}
|
||||
|
||||
#forcedelete testrbu.db
|
||||
finish_test
|
||||
@@ -0,0 +1,139 @@
|
||||
# 2014 October 22
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbucrash
|
||||
|
||||
# Set up a target database and an rbu update database. The target
|
||||
# db is the usual "test.db", the rbu db is "test.db2".
|
||||
#
|
||||
forcedelete test.db2
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a, b, c, PRIMARY KEY(a), UNIQUE(b));
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
INSERT INTO t1 VALUES(7, 8, 9);
|
||||
|
||||
ATTACH 'test.db2' AS rbu;
|
||||
CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(10, 11, 12, 0);
|
||||
INSERT INTO data_t1 VALUES(13, 14, 15, 0);
|
||||
INSERT INTO data_t1 VALUES(4, NULL, NULL, 1);
|
||||
INSERT INTO data_t1 VALUES(1, NULL, 100, '..x');
|
||||
}
|
||||
db_save_and_close
|
||||
|
||||
|
||||
# Determine the number of steps in applying the rbu update to the test
|
||||
# target database created above. Set $::rbu_num_steps accordingly
|
||||
#
|
||||
# Check that the same number of steps are required to apply the rbu
|
||||
# update using many calls to sqlite3rbu_step() on a single rbu handle
|
||||
# as required to apply it using a series of rbu handles, on each of
|
||||
# which sqlite3rbu_step() is called once.
|
||||
#
|
||||
do_test 1.1 {
|
||||
db_restore
|
||||
sqlite3rbu rbu test.db test.db2
|
||||
set nStep 0
|
||||
while {[rbu step]=="SQLITE_OK"} { incr nStep }
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
set rbu_num_steps $nStep
|
||||
do_test 1.2 {
|
||||
db_restore
|
||||
set nStep 0
|
||||
while {1} {
|
||||
sqlite3rbu rbu test.db test.db2
|
||||
rbu step
|
||||
if {[rbu close]=="SQLITE_DONE"} break
|
||||
incr nStep
|
||||
}
|
||||
set nStep
|
||||
} $rbu_num_steps
|
||||
|
||||
|
||||
# Run one or more tests using the target (test.db) and rbu (test.db2)
|
||||
# databases created above. As follows:
|
||||
#
|
||||
# 1. This process starts the rbu update and calls sqlite3rbu_step()
|
||||
# $nPre times. Then closes the rbu update handle.
|
||||
#
|
||||
# 2. A second process resumes the rbu update and attempts to call
|
||||
# sqlite3rbu_step() $nStep times before closing the handle. A
|
||||
# crash is simulated during each xSync() of file test.db2.
|
||||
#
|
||||
# 3. This process attempts to resume the rbu update from whatever
|
||||
# state it was left in by step (2). Test that it is successful
|
||||
# in doing so and that the final target database is as expected.
|
||||
#
|
||||
# In total (nSync+1) tests are run, where nSync is the number of times
|
||||
# xSync() is called on test.db2.
|
||||
#
|
||||
proc do_rbu_crash_test {tn nPre nStep} {
|
||||
|
||||
set script [subst -nocommands {
|
||||
sqlite3rbu rbu test.db file:test.db2?vfs=crash
|
||||
set i 0
|
||||
while {[set i] < $nStep} {
|
||||
if {[rbu step]!="SQLITE_OK"} break
|
||||
incr i
|
||||
}
|
||||
rbu close
|
||||
}]
|
||||
|
||||
set bDone 0
|
||||
for {set iDelay 1} {$bDone==0} {incr iDelay} {
|
||||
forcedelete test.db2 test.db2-journal test.db test.db-oal test.db-wal
|
||||
db_restore
|
||||
|
||||
if {$nPre>0} {
|
||||
sqlite3rbu rbu test.db file:test.db2
|
||||
set i 0
|
||||
for {set i 0} {$i < $nPre} {incr i} {
|
||||
if {[rbu step]!="SQLITE_OK"} break
|
||||
}
|
||||
rbu close
|
||||
}
|
||||
|
||||
set res [
|
||||
crashsql -file test.db2 -delay $iDelay -tclbody $script -opendb {} {}
|
||||
]
|
||||
|
||||
set bDone 1
|
||||
if {$res == "1 {child process exited abnormally}"} {
|
||||
set bDone 0
|
||||
} elseif {$res != "0 {}"} {
|
||||
error "unexected catchsql result: $res"
|
||||
}
|
||||
|
||||
sqlite3rbu rbu test.db test.db2
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
|
||||
sqlite3 db test.db
|
||||
do_execsql_test $tn.delay=$iDelay {
|
||||
SELECT * FROM t1;
|
||||
PRAGMA integrity_check;
|
||||
} {1 2 100 7 8 9 10 11 12 13 14 15 ok}
|
||||
db close
|
||||
}
|
||||
}
|
||||
|
||||
for {set nPre 0} {$nPre < $rbu_num_steps} {incr nPre} {
|
||||
for {set is 1} {$is <= ($rbu_num_steps - $nPre)} {incr is} {
|
||||
do_rbu_crash_test 2.pre=$nPre.step=$is $nPre $is
|
||||
}
|
||||
}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,97 @@
|
||||
# 2017 March 02
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbucrash2
|
||||
|
||||
# Set up a target database and an rbu update database. The target
|
||||
# db is the usual "test.db", the rbu db is "test.db2".
|
||||
#
|
||||
forcedelete test.db2
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a, b, c, PRIMARY KEY(a), UNIQUE(b));
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
INSERT INTO t1 VALUES(7, 8, 9);
|
||||
|
||||
ATTACH 'test.db2' AS rbu;
|
||||
CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES('one', randomblob(3500), NULL, 0);
|
||||
INSERT INTO data_t1 VALUES('two', randomblob(3500), NULL, 0);
|
||||
INSERT INTO data_t1 VALUES('three', randomblob(3500), NULL, 0);
|
||||
INSERT INTO data_t1 VALUES('four', randomblob(3500), NULL, 0);
|
||||
INSERT INTO data_t1 VALUES('five', randomblob(3500), NULL, 0);
|
||||
INSERT INTO data_t1 VALUES('six', randomblob(3500), NULL, 0);
|
||||
}
|
||||
db_save_and_close
|
||||
|
||||
proc do_rbu_crash_test2 {tn script} {
|
||||
|
||||
foreach {f blksz} {
|
||||
test.db 512
|
||||
test.db2 512
|
||||
test.db 4096
|
||||
test.db2 4096
|
||||
} {
|
||||
set bDone 0
|
||||
for {set iDelay 1} {$bDone==0} {incr iDelay} {
|
||||
forcedelete test.db2 test.db2-journal test.db test.db-oal test.db-wal
|
||||
db_restore
|
||||
|
||||
set res [
|
||||
crashsql -file $f -delay $iDelay -tclbody $script -dflt 1 -opendb {} \
|
||||
-blocksize $blksz {}
|
||||
]
|
||||
|
||||
set bDone 1
|
||||
if {$res == "1 {child process exited abnormally}"} {
|
||||
set bDone 0
|
||||
} elseif {$res != "0 {}"} {
|
||||
error "unexected catchsql result: $res"
|
||||
}
|
||||
|
||||
sqlite3rbu rbu test.db test.db2
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
|
||||
sqlite3 db test.db
|
||||
do_execsql_test $tn.delay=$iDelay.f=$f.blksz=$blksz {
|
||||
PRAGMA integrity_check;
|
||||
} {ok}
|
||||
db close
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for {set x 1} {$x < 10} {incr x} {
|
||||
do_rbu_crash_test2 1.$x {
|
||||
sqlite3rbu rbu test.db test.db2
|
||||
while {[rbu step]=="SQLITE_OK"} {
|
||||
rbu savestate
|
||||
}
|
||||
rbu close
|
||||
}
|
||||
}
|
||||
|
||||
for {set x 1} {$x < 2} {incr x} {
|
||||
do_rbu_crash_test2 2.$x {
|
||||
sqlite3rbu rbu test.db test.db2
|
||||
while {[rbu step]=="SQLITE_OK"} {
|
||||
rbu close
|
||||
sqlite3rbu rbu test.db test.db2
|
||||
}
|
||||
rbu close
|
||||
}
|
||||
}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,309 @@
|
||||
# 2015-07-31
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
# Tests for the [sqldiff --rbu] command.
|
||||
#
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set testprefix rbudiff
|
||||
|
||||
set PROG [test_find_sqldiff]
|
||||
db close
|
||||
|
||||
proc get_rbudiff_sql {db1 db2} {
|
||||
exec $::PROG --rbu $db1 $db2
|
||||
}
|
||||
|
||||
proc get_vtab_rbudiff_sql {db1 db2} {
|
||||
exec $::PROG --vtab --rbu $db1 $db2
|
||||
}
|
||||
|
||||
proc step_rbu {target rbu} {
|
||||
while 1 {
|
||||
sqlite3rbu rbu $target $rbu
|
||||
set rc [rbu step]
|
||||
rbu close
|
||||
if {$rc != "SQLITE_OK"} break
|
||||
}
|
||||
set rc
|
||||
}
|
||||
|
||||
proc apply_rbudiff {sql target} {
|
||||
test_rbucount $sql
|
||||
forcedelete rbu.db
|
||||
sqlite3 rbudb rbu.db
|
||||
rbudb eval $sql
|
||||
rbudb close
|
||||
step_rbu $target rbu.db
|
||||
}
|
||||
|
||||
proc sqlesc {id} {
|
||||
set ret "'[string map {' ''} $id]'"
|
||||
set ret
|
||||
}
|
||||
|
||||
# The only argument is the output of an [sqldiff -rbu] run. This command
|
||||
# tests that the contents of the rbu_count table is correct. An exception
|
||||
# is thrown if it is not.
|
||||
#
|
||||
proc test_rbucount {sql} {
|
||||
sqlite3 tmpdb ""
|
||||
tmpdb eval $sql
|
||||
tmpdb eval {
|
||||
SELECT name FROM sqlite_master WHERE name LIKE 'data%' AND type='table'
|
||||
} {
|
||||
set a [tmpdb eval "SELECT count(*) FROM [sqlesc $name]"]
|
||||
set b [tmpdb eval {SELECT cnt FROM rbu_count WHERE tbl = $name}]
|
||||
if {$a != $b} {
|
||||
tmpdb close
|
||||
error "rbu_count error - tbl = $name"
|
||||
}
|
||||
}
|
||||
tmpdb close
|
||||
return ""
|
||||
}
|
||||
|
||||
proc rbudiff_cksum {db1} {
|
||||
set txt ""
|
||||
|
||||
sqlite3 dbtmp $db1
|
||||
foreach tbl [dbtmp eval {SELECT name FROM sqlite_master WHERE type='table'}] {
|
||||
set cols [list]
|
||||
dbtmp eval "PRAGMA table_info = [sqlesc $tbl]" {
|
||||
lappend cols "quote( $name )"
|
||||
}
|
||||
append txt [dbtmp eval \
|
||||
"SELECT [join $cols {||'.'||}] FROM [sqlesc $tbl] ORDER BY 1"
|
||||
]
|
||||
}
|
||||
dbtmp close
|
||||
|
||||
md5 $txt
|
||||
}
|
||||
|
||||
foreach {tn init mod} {
|
||||
1 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
|
||||
CREATE TABLE t2(a, b, c, PRIMARY KEY(b, c));
|
||||
INSERT INTO t2 VALUES(1, 2, 3);
|
||||
INSERT INTO t2 VALUES(4, 5, 6);
|
||||
} {
|
||||
INSERT INTO t1 VALUES(7, 8, 9);
|
||||
DELETE FROM t1 WHERE a=4;
|
||||
UPDATE t1 SET c = 11 WHERE a = 1;
|
||||
|
||||
INSERT INTO t2 VALUES(7, 8, 9);
|
||||
DELETE FROM t2 WHERE a=4;
|
||||
UPDATE t2 SET c = 11 WHERE a = 1;
|
||||
}
|
||||
|
||||
2 {
|
||||
CREATE TABLE t1(a, b, c, PRIMARY KEY(a, b, c));
|
||||
INSERT INTO t1 VALUES('u', 'v', 'w');
|
||||
INSERT INTO t1 VALUES('x', 'y', 'z');
|
||||
} {
|
||||
DELETE FROM t1 WHERE a='u';
|
||||
INSERT INTO t1 VALUES('a', 'b', 'c');
|
||||
}
|
||||
|
||||
3 {
|
||||
CREATE TABLE t1(i INTEGER PRIMARY KEY, x);
|
||||
INSERT INTO t1 VALUES(1,
|
||||
X'0000000000000000111111111111111122222222222222223333333333333333'
|
||||
);
|
||||
CREATE TABLE t2(y INTEGER PRIMARY KEY, x);
|
||||
INSERT INTO t2 VALUES(1,
|
||||
X'0000000000000000111111111111111122222222222222223333333333333333'
|
||||
);
|
||||
} {
|
||||
DELETE FROM t1;
|
||||
INSERT INTO t1 VALUES(1,
|
||||
X'0000000000000000111111111111111122222555555552223333333333333333'
|
||||
);
|
||||
DELETE FROM t2;
|
||||
INSERT INTO t2 VALUES(1,
|
||||
X'0000000000000000111111111111111122222222222222223333333FFF333333'
|
||||
);
|
||||
}
|
||||
|
||||
4 {
|
||||
CREATE TABLE x1(a, b, c, PRIMARY KEY(a, b, c));
|
||||
INSERT INTO x1 VALUES('u', 'v', NULL);
|
||||
INSERT INTO x1 VALUES('x', 'y', 'z');
|
||||
INSERT INTO x1 VALUES('a', NULL, 'b');
|
||||
} {
|
||||
INSERT INTO x1 VALUES('a', 'b', 'c');
|
||||
}
|
||||
|
||||
5 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b);
|
||||
INSERT INTO t1 VALUES(1, NULL);
|
||||
INSERT INTO t1 VALUES(2, X'');
|
||||
} {
|
||||
UPDATE t1 SET b = X'' WHERE a=1;
|
||||
UPDATE t1 SET b = NULL WHERE a=2;
|
||||
}
|
||||
|
||||
} {
|
||||
catch { db close }
|
||||
|
||||
forcedelete test.db test.db2
|
||||
sqlite3 db test.db
|
||||
db eval "$init"
|
||||
sqlite3 db test.db2
|
||||
db eval "$init ; $mod"
|
||||
db close
|
||||
|
||||
do_test 1.$tn.2 {
|
||||
set sql [get_rbudiff_sql test.db test.db2]
|
||||
apply_rbudiff $sql test.db
|
||||
} {SQLITE_DONE}
|
||||
do_test 1.$tn.3 { rbudiff_cksum test.db } [rbudiff_cksum test.db2]
|
||||
|
||||
forcedelete test.db test.db2
|
||||
sqlite3 db test.db
|
||||
db eval "$init ; $mod"
|
||||
sqlite3 db test.db2
|
||||
db eval "$init"
|
||||
db close
|
||||
|
||||
do_test 1.$tn.4 {
|
||||
set sql [get_rbudiff_sql test.db test.db2]
|
||||
apply_rbudiff $sql test.db
|
||||
} {SQLITE_DONE}
|
||||
do_test 1.$tn.5 { rbudiff_cksum test.db } [rbudiff_cksum test.db2]
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that if the --vtab switch is present, [sqldiff] handles virtual
|
||||
# table types fts[345] and rtree correctly.
|
||||
#
|
||||
ifcapable fts3&&fts5&&rtree {
|
||||
|
||||
foreach {tn init mod} {
|
||||
1 {
|
||||
CREATE VIRTUAL TABLE t1 USING fts5(c);
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
} {
|
||||
DELETE FROM t1 WHERE rowid = 1;
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
}
|
||||
|
||||
2 {
|
||||
CREATE VIRTUAL TABLE "x y" USING 'rtree'(id, x1, x2);
|
||||
INSERT INTO "x y" VALUES(1, 2, 3);
|
||||
INSERT INTO "x y" VALUES(2, 4, 6);
|
||||
} {
|
||||
DELETE FROM "x y" WHERE rowid = 1;
|
||||
INSERT INTO "x y" VALUES(3, 6, 9);
|
||||
}
|
||||
|
||||
3 {
|
||||
CREATE VIRTUAL TABLE 'x''y' USING fts3;
|
||||
INSERT INTO 'x''y' VALUES('one two three');
|
||||
INSERT INTO 'x''y' VALUES('four five six');
|
||||
} {
|
||||
DELETE FROM 'x''y' WHERE rowid = 1;
|
||||
INSERT INTO 'x''y' VALUES('one two three');
|
||||
}
|
||||
} {
|
||||
|
||||
forcedelete test.db test.db2
|
||||
sqlite3 db test.db
|
||||
db eval "$init"
|
||||
sqlite3 db test.db2
|
||||
db eval "$init ; $mod"
|
||||
db close
|
||||
|
||||
do_test 2.$tn.1 {
|
||||
set sql [get_vtab_rbudiff_sql test.db test.db2]
|
||||
apply_rbudiff $sql test.db
|
||||
} {SQLITE_DONE}
|
||||
do_test 2.$tn.2 { rbudiff_cksum test.db } [rbudiff_cksum test.db2]
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
ifcapable fts5 {
|
||||
foreach {tn init mod} {
|
||||
1 {
|
||||
CREATE VIRTUAL TABLE t1 USING fts5(c);
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
} {
|
||||
DELETE FROM t1 WHERE rowid = 1;
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
}
|
||||
|
||||
2 {
|
||||
CREATE VIRTUAL TABLE t1 USING FTs5(c);
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
} {
|
||||
DELETE FROM t1 WHERE rowid = 1;
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
}
|
||||
|
||||
3 {
|
||||
creAte virTUal
|
||||
tablE t1 USING FTs5(c);
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
} {
|
||||
DELETE FROM t1 WHERE rowid = 1;
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
}
|
||||
4 {
|
||||
creAte virTUal tablE t1 USING FTs5(c);
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
} {
|
||||
DELETE FROM t1 WHERE rowid = 1;
|
||||
INSERT INTO t1 VALUES('a b c');
|
||||
}
|
||||
|
||||
} {
|
||||
forcedelete test.db test.db2
|
||||
sqlite3 db test.db
|
||||
db eval "$init"
|
||||
sqlite3 db test.db2
|
||||
db eval "$init ; $mod"
|
||||
db eval { INSERT INTO t1(t1) VALUES('optimize') }
|
||||
db close
|
||||
|
||||
do_test 3.$tn.1 {
|
||||
set sql [get_vtab_rbudiff_sql test.db test.db2]
|
||||
apply_rbudiff $sql test.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
sqlite3 db test.db
|
||||
sqlite3 db2 test.db2
|
||||
do_test 3.$tn.2 {
|
||||
db2 eval { SELECT * FROM t1 ORDER BY rowid }
|
||||
} [db eval { SELECT * FROM t1 ORDER BY rowid }]
|
||||
|
||||
do_test 3.$tn.3 {
|
||||
db2 eval { INSERT INTO t1(t1) VALUES('integrity-check') }
|
||||
} {}
|
||||
|
||||
db close
|
||||
db2 close
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,56 @@
|
||||
# 2016 October 21
|
||||
#
|
||||
# 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 test file focuses on interactions between RBU and the feature
|
||||
# enabled by SQLITE_DIRECT_OVERFLOW_READ - Direct Overflow Read.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbudor
|
||||
|
||||
set bigA [string repeat a 5000]
|
||||
set bigB [string repeat b 5000]
|
||||
do_execsql_test 1.0 {
|
||||
PRAGMA page_size = 1024;
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b BLOB);
|
||||
INSERT INTO t1 VALUES(1, $bigA);
|
||||
} {}
|
||||
|
||||
do_test 1.1 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 rbu rbu.db
|
||||
rbu eval {
|
||||
CREATE TABLE data_t1(a, b, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(2, $bigB, 0);
|
||||
}
|
||||
rbu close
|
||||
} {}
|
||||
|
||||
do_test 1.2 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while {[rbu state]!="checkpoint"} {
|
||||
rbu step
|
||||
}
|
||||
rbu step
|
||||
db eval { SELECT * FROM t1 }
|
||||
} [list 1 $bigA 2 $bigB]
|
||||
|
||||
do_test 1.3 {
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 1.4 {
|
||||
SELECT * FROM t1
|
||||
} [list 1 $bigA 2 $bigB]
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,292 @@
|
||||
# 2021 November 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbuexlock
|
||||
|
||||
db close
|
||||
|
||||
set journalmode delete
|
||||
if {[permutation]=="inmemory_journal"} {
|
||||
set journalmode memory
|
||||
}
|
||||
|
||||
# Create a simple RBU database. That expects to write to a table:
|
||||
#
|
||||
# CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
#
|
||||
proc create_rbu {filename} {
|
||||
forcedelete $filename
|
||||
sqlite3 rbu1 $filename
|
||||
rbu1 eval {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(10, random(), random(), 0);
|
||||
INSERT INTO data_t1 VALUES(20, random(), random(), 0);
|
||||
INSERT INTO data_t1 VALUES(30, random(), random(), 0);
|
||||
INSERT INTO data_t1 VALUES(40, random(), random(), 0);
|
||||
INSERT INTO data_t1 VALUES(50, random(), random(), 0);
|
||||
INSERT INTO data_t1 VALUES(60, random(), random(), 0);
|
||||
INSERT INTO data_t1 VALUES(70, random(), random(), 0);
|
||||
INSERT INTO data_t1 VALUES(80, random(), random(), 0);
|
||||
}
|
||||
rbu1 close
|
||||
return $filename
|
||||
}
|
||||
|
||||
reset_db
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b INT, c INT);
|
||||
CREATE INDEX t1b ON t1(b);
|
||||
CREATE INDEX t1c ON t1(c);
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
}
|
||||
create_rbu rbu1.db
|
||||
|
||||
do_test 1.1.0 {
|
||||
sqlite3rbu rbu file:test.db?rbu_exclusive_checkpoint=1 rbu1.db
|
||||
rbu step
|
||||
} SQLITE_OK
|
||||
do_catchsql_test 1.1.1 { SELECT * FROM t1 } {0 {1 2 3}}
|
||||
|
||||
do_test 1.2.0 {
|
||||
for {set ii 0} {$ii < 10} {incr ii} {
|
||||
rbu step
|
||||
}
|
||||
rbu step
|
||||
} SQLITE_OK
|
||||
do_catchsql_test 1.2.1 { SELECT * FROM t1 } {0 {1 2 3}}
|
||||
do_test 1.2.2 {
|
||||
db eval {PRAGMA journal_mode}
|
||||
} $journalmode
|
||||
|
||||
do_test 1.3.0 {
|
||||
while {[file exists test.db-wal]==0} {
|
||||
rbu step
|
||||
}
|
||||
} {}
|
||||
do_catchsql_test 1.3.1 { SELECT * FROM t1 } {1 {database is locked}}
|
||||
do_test 1.3.2 {
|
||||
db eval {PRAGMA journal_mode}
|
||||
} $journalmode
|
||||
|
||||
|
||||
do_test 1.4.0 {
|
||||
rbu step
|
||||
} SQLITE_OK
|
||||
do_catchsql_test 1.4.1 { SELECT * FROM t1 } {1 {database is locked}}
|
||||
do_test 1.4.2 {
|
||||
db eval {PRAGMA journal_mode}
|
||||
} $journalmode
|
||||
|
||||
|
||||
rbu close
|
||||
|
||||
do_test 1.5.0 {
|
||||
file exists test.db-wal
|
||||
} {1}
|
||||
do_test 1.5.1 {
|
||||
sqlite3rbu rbu file:test.db?rbu_exclusive_checkpoint=1 rbu1.db
|
||||
file exists test.db-wal
|
||||
} 1
|
||||
do_catchsql_test 1.5.2 { SELECT * FROM t1 } {1 {database is locked}}
|
||||
do_test 1.5.2 {
|
||||
db eval {PRAGMA journal_mode}
|
||||
} $journalmode
|
||||
|
||||
|
||||
do_test 1.6.0 {
|
||||
rbu step
|
||||
} SQLITE_OK
|
||||
do_catchsql_test 1.6.1 { SELECT * FROM t1 } {1 {database is locked}}
|
||||
do_test 1.6.2 {
|
||||
db eval {PRAGMA journal_mode}
|
||||
} $journalmode
|
||||
|
||||
do_test 1.7.0 {
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
} SQLITE_DONE
|
||||
do_catchsql_test 1.7.2 { SELECT count(*) FROM t1 } {0 9}
|
||||
do_test 1.7.2 {
|
||||
db eval {PRAGMA journal_mode}
|
||||
} $journalmode
|
||||
|
||||
reset_db
|
||||
do_execsql_test 2.0 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b INT, c INT);
|
||||
CREATE INDEX t1b ON t1(b);
|
||||
CREATE INDEX t1c ON t1(c);
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
}
|
||||
create_rbu rbu1.db
|
||||
|
||||
do_test 2.1.0 {
|
||||
sqlite3rbu rbu file:test.db?rbu_exclusive_checkpoint=0 rbu1.db
|
||||
rbu step
|
||||
} SQLITE_OK
|
||||
do_catchsql_test 2.1.1 { SELECT * FROM t1 } {0 {1 2 3}}
|
||||
|
||||
do_test 2.2.0 {
|
||||
for {set ii 0} {$ii < 10} {incr ii} {
|
||||
rbu step
|
||||
}
|
||||
rbu step
|
||||
} SQLITE_OK
|
||||
do_catchsql_test 2.2.1 { SELECT * FROM t1 } {0 {1 2 3}}
|
||||
|
||||
do_test 2.3.0 {
|
||||
while {[file exists test.db-wal]==0} {
|
||||
rbu step
|
||||
}
|
||||
} {}
|
||||
do_test 2.3.1 {
|
||||
llength [db eval {SELECT * FROM t1}]
|
||||
} {27}
|
||||
do_test 2.3.2 {
|
||||
db eval {PRAGMA journal_mode}
|
||||
} {wal}
|
||||
|
||||
do_test 2.4.0 {
|
||||
rbu step
|
||||
} SQLITE_OK
|
||||
do_test 2.4.1 {
|
||||
llength [db eval {SELECT * FROM t1}]
|
||||
} {27}
|
||||
do_test 2.4.2 {
|
||||
db eval {PRAGMA journal_mode}
|
||||
} {wal}
|
||||
|
||||
rbu close
|
||||
|
||||
do_test 2.5.0 {
|
||||
db eval {PRAGMA journal_mode}
|
||||
} {wal}
|
||||
do_execsql_test 2.5.1 {
|
||||
DELETE FROM t1;
|
||||
} {}
|
||||
|
||||
create_rbu rbu1.db
|
||||
do_test 3.1.0 {
|
||||
sqlite3rbu rbu file:test.db?rbu_exclusive_checkpoint=0 rbu1.db
|
||||
rbu step
|
||||
} SQLITE_ERROR
|
||||
|
||||
do_test 3.1.1 {
|
||||
set rc [catch {rbu close} msg]
|
||||
lappend rc $msg
|
||||
} {1 {SQLITE_ERROR - cannot update wal mode database}}
|
||||
db eval {PRAGMA journal_mode=DELETE}
|
||||
|
||||
create_rbu rbu1.db
|
||||
do_test 3.2.0 {
|
||||
sqlite3rbu rbu file:test.db?rbu_exclusive_checkpoint=0 rbu1.db
|
||||
rbu step
|
||||
} SQLITE_OK
|
||||
|
||||
do_test 3.3.1 {
|
||||
set rc [catch {rbu close} msg]
|
||||
lappend rc $msg
|
||||
} {0 SQLITE_OK}
|
||||
|
||||
db close
|
||||
create_rbu rbu1.db
|
||||
do_test 3.4.0 {
|
||||
sqlite3rbu rbu file:test.db?rbu_exclusive_checkpoint=0 rbu1.db
|
||||
rbu step
|
||||
} SQLITE_OK
|
||||
rbu close
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
reset_db
|
||||
forcedelete rbu1.db
|
||||
forcedelete rbu2.db
|
||||
|
||||
sqlite3 rbu rbu1.db
|
||||
do_execsql_test -db rbu 4.1 {
|
||||
CREATE TABLE data_t1(a, b, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 'one', 0);
|
||||
}
|
||||
rbu close
|
||||
sqlite3 rbu rbu2.db
|
||||
do_execsql_test -db rbu 4.2 {
|
||||
CREATE TABLE data_t1(a, b, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(2, 'two', 0);
|
||||
}
|
||||
rbu close
|
||||
|
||||
do_execsql_test 4.3 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b);
|
||||
}
|
||||
db close
|
||||
|
||||
do_test 4.4 {
|
||||
sqlite3rbu rbu file:test.db?rbu_exclusive_checkpoint=1 rbu1.db
|
||||
rbu step
|
||||
rbu state
|
||||
} {oal}
|
||||
|
||||
sqlite3 cons test.db
|
||||
do_execsql_test -db cons 4.5 {
|
||||
SELECT * FROM t1
|
||||
} {}
|
||||
|
||||
do_test 4.6 { rbu step ; rbu state } {oal}
|
||||
do_test 4.7 { rbu step ; rbu state } {move}
|
||||
do_execsql_test -db cons 4.8 {
|
||||
SELECT * FROM t1
|
||||
} {}
|
||||
do_test 4.9 { rbu step ; rbu state } {checkpoint}
|
||||
do_test 4.10 {
|
||||
catchsql { SELECT * FROM t1 } cons
|
||||
} {1 {database is locked}}
|
||||
do_test 4.11 { rbu step ; rbu state } {checkpoint}
|
||||
do_test 4.11 { rbu step ; rbu state } {done}
|
||||
rbu close
|
||||
|
||||
do_test 4.12 {
|
||||
catchsql { SELECT * FROM t1 } cons
|
||||
} {0 {1 one}}
|
||||
|
||||
do_test 4.13 {
|
||||
sqlite3rbu rbu file:test.db?rbu_exclusive_checkpoint=1 rbu2.db
|
||||
rbu step
|
||||
rbu state
|
||||
} {oal}
|
||||
|
||||
do_test 4.14 {
|
||||
catchsql { SELECT * FROM t1 } cons
|
||||
} {0 {1 one}}
|
||||
|
||||
do_test 4.15 { rbu step ; rbu state } {oal}
|
||||
do_test 4.16 { rbu step ; rbu state } {move}
|
||||
|
||||
do_test 4.17 {
|
||||
catchsql { SELECT * FROM t1 } cons
|
||||
} {0 {1 one}}
|
||||
|
||||
do_test 4.18 { rbu step ; rbu state } {checkpoint}
|
||||
do_test 4.19 {
|
||||
catchsql { SELECT * FROM t1 } cons
|
||||
} {1 {database is locked}}
|
||||
do_test 4.20 { rbu step ; rbu state } {checkpoint}
|
||||
do_test 4.21 { rbu step ; rbu state } {done}
|
||||
rbu close
|
||||
|
||||
do_test 4.22 {
|
||||
catchsql { SELECT * FROM t1 } cons
|
||||
} {0 {1 one 2 two}}
|
||||
|
||||
cons close
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,88 @@
|
||||
# 2014 August 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbuexpr
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a, b, c PRIMARY KEY);
|
||||
CREATE INDEX i1 ON t1(a, null, b+1);
|
||||
CREATE INDEX i2 ON t1(a+1, b+1, c+1);
|
||||
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
INSERT INTO t1 VALUES(7, 8, 9);
|
||||
INSERT INTO t1 VALUES(10, 11, 12);
|
||||
|
||||
PRAGMA integrity_check;
|
||||
} {ok}
|
||||
|
||||
forcedelete rbu.db
|
||||
sqlite3 db2 rbu.db
|
||||
do_execsql_test -db db2 1.1 {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(13, 14, 15, 0);
|
||||
INSERT INTO data_t1 VALUES(NULL, NULL, 6, 1);
|
||||
INSERT INTO data_t1 VALUES(NULL, 'three', 3, '.x.');
|
||||
}
|
||||
db2 close
|
||||
db close
|
||||
|
||||
do_test 1.2 {
|
||||
run_rbu test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
sqlite3 db test.db
|
||||
|
||||
do_execsql_test 1.3 {
|
||||
SELECT * FROM t1 WHERE a=4;
|
||||
}
|
||||
|
||||
integrity_check 1.4
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 2.0 {
|
||||
CREATE TABLE t1(c1, c2, c3, i INTEGER PRIMARY KEY);
|
||||
INSERT INTO t1 VALUES('one', 'one', 'one', 1);
|
||||
INSERT INTO t1 VALUES('two', 'two', 'two', 2);
|
||||
INSERT INTO t1 VALUES('three', 'three', 'three', 3);
|
||||
INSERT INTO t1 VALUES('four', 'four', 'four', 4);
|
||||
|
||||
CREATE INDEX i1 ON t1( substr(c1, 1, 2) );
|
||||
CREATE INDEX i2 ON t1( c1 || c2 || c3 );
|
||||
CREATE INDEX i3 ON t1( length(c1) + length(c2) - 1, c3||i );
|
||||
}
|
||||
|
||||
forcedelete rbu.db
|
||||
sqlite3 db2 rbu.db
|
||||
do_execsql_test -db db2 2.1 {
|
||||
CREATE TABLE data_t1(c1, c2, c3, i, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(NULL, NULL, NULL, 2, 1);
|
||||
INSERT INTO data_t1 VALUES('thirty', NULL, NULL, 3, 'xx..');
|
||||
INSERT INTO data_t1 VALUES('five', 'five', 'five', 5, 0);
|
||||
}
|
||||
db2 close
|
||||
|
||||
db close
|
||||
|
||||
do_test 2.2 {
|
||||
run_rbu test.db rbu.db
|
||||
} {SQLITE_DONE}
|
||||
|
||||
sqlite3 db test.db
|
||||
integrity_check 2.3
|
||||
|
||||
finish_test
|
||||
|
||||
@@ -0,0 +1,234 @@
|
||||
# 2014 October 22
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
source $testdir/malloc_common.tcl
|
||||
set ::testprefix rbufault
|
||||
|
||||
proc copy_if_exists {src target} {
|
||||
if {[file exists $src]} {
|
||||
forcecopy $src $target
|
||||
} else {
|
||||
forcedelete $target
|
||||
}
|
||||
}
|
||||
|
||||
foreach {tn2 setup sql expect} {
|
||||
1 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX t1cb ON t1(c, b);
|
||||
INSERT INTO t1 VALUES(1, 1, 1);
|
||||
INSERT INTO t1 VALUES(2, 2, 2);
|
||||
INSERT INTO t1 VALUES(3, 3, 3);
|
||||
|
||||
CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(2, NULL, NULL, 1);
|
||||
INSERT INTO data_t1 VALUES(3, 'three', NULL, '.x.');
|
||||
INSERT INTO data_t1 VALUES(4, 4, 4, 0);
|
||||
} {
|
||||
SELECT * FROM t1
|
||||
} {1 1 1 3 three 3 4 4 4}
|
||||
|
||||
2 {
|
||||
CREATE TABLE t2(a PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
CREATE INDEX t2cb ON t2(c, b);
|
||||
INSERT INTO t2 VALUES('a', 'a', 'a');
|
||||
INSERT INTO t2 VALUES('b', 'b', 'b');
|
||||
INSERT INTO t2 VALUES('c', 'c', 'c');
|
||||
|
||||
CREATE TABLE rbu.data_t2(a, b, c, rbu_control);
|
||||
INSERT INTO data_t2 VALUES('b', NULL, NULL, 1);
|
||||
INSERT INTO data_t2 VALUES('c', 'see', NULL, '.x.');
|
||||
INSERT INTO data_t2 VALUES('d', 'd', 'd', 0);
|
||||
} {
|
||||
SELECT * FROM t2
|
||||
} {a a a c see c d d d}
|
||||
|
||||
3 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE TABLE t2(a PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
CREATE INDEX t1cb ON t1(c, b);
|
||||
CREATE INDEX t2cb ON t2(c, b);
|
||||
|
||||
CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
|
||||
CREATE TABLE rbu.data_t2(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 2, 3, 0);
|
||||
INSERT INTO data_t2 VALUES(4, 5, 6, 0);
|
||||
} {
|
||||
SELECT * FROM t1 UNION ALL SELECT * FROM t2
|
||||
} {1 2 3 4 5 6}
|
||||
|
||||
4 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
CREATE INDEX t1c ON t1(c);
|
||||
INSERT INTO t1 VALUES('A', 'B', 'C');
|
||||
INSERT INTO t1 VALUES('D', 'E', 'F');
|
||||
|
||||
CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES('D', NULL, NULL, 1);
|
||||
INSERT INTO data_t1 VALUES('A', 'Z', NULL, '.x.');
|
||||
INSERT INTO data_t1 VALUES('G', 'H', 'I', 0);
|
||||
} {
|
||||
SELECT * FROM t1 ORDER BY a;
|
||||
} {A Z C G H I}
|
||||
|
||||
5 {
|
||||
CREATE TABLE t1(a, b, c);
|
||||
CREATE INDEX t1c ON t1(c, b);
|
||||
|
||||
CREATE TABLE rbu.data_t1(a, b, c, rbu_rowid, rbu_control);
|
||||
INSERT INTO data_t1 VALUES('a', 'b', 'c', 1, 0);
|
||||
INSERT INTO data_t1 VALUES('d', 'e', 'f', '2', 0);
|
||||
} {
|
||||
SELECT * FROM t1 ORDER BY a;
|
||||
} {a b c d e f}
|
||||
|
||||
} {
|
||||
catch {db close}
|
||||
forcedelete rbu.db test.db
|
||||
sqlite3 db test.db
|
||||
execsql {
|
||||
PRAGMA encoding = utf16;
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
}
|
||||
execsql $setup
|
||||
db close
|
||||
|
||||
forcecopy test.db test.db.bak
|
||||
forcecopy rbu.db rbu.db.bak
|
||||
|
||||
foreach {tn f reslist} {
|
||||
1 oom-tra* {
|
||||
{0 SQLITE_DONE}
|
||||
{1 {SQLITE_NOMEM - out of memory}}
|
||||
{1 SQLITE_NOMEM}
|
||||
{1 SQLITE_IOERR_NOMEM}
|
||||
{1 {SQLITE_NOMEM - unable to open a temporary database file for storing temporary tables}}
|
||||
}
|
||||
|
||||
2 ioerr-* {
|
||||
{0 SQLITE_DONE}
|
||||
{1 {SQLITE_IOERR - disk I/O error}}
|
||||
{1 SQLITE_IOERR}
|
||||
{1 SQLITE_IOERR_WRITE}
|
||||
{1 SQLITE_IOERR_READ}
|
||||
{1 SQLITE_IOERR_FSYNC}
|
||||
{1 {SQLITE_ERROR - SQL logic error}}
|
||||
{1 {SQLITE_ERROR - unable to open database: rbu.db}}
|
||||
{1 {SQLITE_IOERR - unable to open database: rbu.db}}
|
||||
}
|
||||
|
||||
3 shmerr-* {
|
||||
{0 SQLITE_DONE}
|
||||
{1 {SQLITE_IOERR - disk I/O error}}
|
||||
{1 SQLITE_IOERR}
|
||||
}
|
||||
} {
|
||||
|
||||
catch {db close}
|
||||
sqlite3_shutdown
|
||||
set lookaside_config [sqlite3_config_lookaside 0 0]
|
||||
sqlite3_initialize
|
||||
autoinstall_test_functions
|
||||
|
||||
do_faultsim_test 2.$tn2 -faults $::f -prep {
|
||||
catch { db close }
|
||||
forcedelete test.db-journal test.db-wal rbu.db-journal rbu.db-wal
|
||||
forcecopy test.db.bak test.db
|
||||
forcecopy rbu.db.bak rbu.db
|
||||
} -body {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
} -test {
|
||||
faultsim_test_result {*}$::reslist
|
||||
if {$testrc==0} {
|
||||
sqlite3 db test.db
|
||||
faultsim_integrity_check
|
||||
set res [db eval $::sql]
|
||||
if {$res != [list {*}$::expect]} {
|
||||
puts ""
|
||||
puts "res: $res"
|
||||
puts "exp: $expect"
|
||||
error "data not as expected!"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
catch {db close}
|
||||
sqlite3_shutdown
|
||||
sqlite3_config_lookaside {*}$lookaside_config
|
||||
sqlite3_initialize
|
||||
autoinstall_test_functions
|
||||
|
||||
|
||||
for {set iStep 0} {$iStep<=21} {incr iStep} {
|
||||
|
||||
forcedelete test.db-journal test.db-wal rbu.db-journal rbu.db-wal
|
||||
|
||||
copy_if_exists test.db.bak test.db
|
||||
copy_if_exists rbu.db.bak rbu.db
|
||||
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
for {set x 0} {$x < $::iStep} {incr x} { rbu step }
|
||||
rbu close
|
||||
|
||||
# sqlite3 x rbu.db ; puts "XYZ [x eval { SELECT * FROM rbu_state } ]" ; x close
|
||||
|
||||
copy_if_exists test.db test.db.bak.2
|
||||
copy_if_exists test.db-wal test.db.bak.2-wal
|
||||
copy_if_exists test.db-oal test.db.bak.2-oal
|
||||
copy_if_exists rbu.db rbu.db.bak.2
|
||||
|
||||
do_faultsim_test 3.$tn.$iStep -faults $::f -prep {
|
||||
catch { db close }
|
||||
forcedelete test.db-journal test.db-wal rbu.db-journal rbu.db-wal
|
||||
copy_if_exists test.db.bak.2 test.db
|
||||
copy_if_exists test.db.bak.2-wal test.db-wal
|
||||
copy_if_exists test.db.bak.2-oal test.db-oal
|
||||
copy_if_exists rbu.db.bak.2 rbu.db
|
||||
} -body {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
rbu close
|
||||
} -test {
|
||||
|
||||
if {$testresult=="SQLITE_OK"} {set testresult "SQLITE_DONE"}
|
||||
faultsim_test_result {*}$::reslist
|
||||
|
||||
if {$testrc==0} {
|
||||
# No error occurred. If the RBU has not already been fully applied,
|
||||
# apply the rest of it now. Then ensure that the final state of the
|
||||
# target db is as expected. And that "PRAGMA integrity_check"
|
||||
# passes.
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
while {[rbu step] == "SQLITE_OK"} {}
|
||||
rbu close
|
||||
|
||||
sqlite3 db test.db
|
||||
faultsim_integrity_check
|
||||
|
||||
set res [db eval $::sql]
|
||||
if {$res != [list {*}$::expect]} {
|
||||
puts ""
|
||||
puts "res: $res"
|
||||
puts "exp: $::expect"
|
||||
error "data not as expected!"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,64 @@
|
||||
# 2014 October 22
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
source $testdir/malloc_common.tcl
|
||||
set ::testprefix rbufault2
|
||||
|
||||
forcedelete rbu.db
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE target(x UNIQUE, y, z, PRIMARY KEY(y));
|
||||
INSERT INTO target VALUES(1, 2, 3);
|
||||
INSERT INTO target VALUES(4, 5, 6);
|
||||
|
||||
ATTACH 'rbu.db' AS rbu;
|
||||
CREATE TABLE rbu.data_target(x, y, z, rbu_control);
|
||||
INSERT INTO data_target VALUES(7, 8, 9, 0);
|
||||
INSERT INTO data_target VALUES(1, 11, 12, 0);
|
||||
DETACH rbu;
|
||||
}
|
||||
db close
|
||||
|
||||
forcecopy test.db test.db-bak
|
||||
forcecopy rbu.db rbu.db-bak
|
||||
|
||||
do_faultsim_test 1 -faults oom* -prep {
|
||||
forcecopy test.db-bak test.db
|
||||
forcecopy rbu.db-bak rbu.db
|
||||
forcedelete test.db-oal test.db-wal rbu.db-journal
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
} -body {
|
||||
while {[rbu step]=="SQLITE_OK"} { }
|
||||
rbu close
|
||||
} -test {
|
||||
faultsim_test_result \
|
||||
{1 {SQLITE_CONSTRAINT - UNIQUE constraint failed: target.x}} \
|
||||
{1 SQLITE_CONSTRAINT} \
|
||||
{1 SQLITE_NOMEM} \
|
||||
{1 {SQLITE_NOMEM - unable to open a temporary database file for storing temporary tables}} \
|
||||
{1 {SQLITE_NOMEM - out of memory}}
|
||||
}
|
||||
|
||||
|
||||
sqlite3rbu_create_vfs -default rbu ""
|
||||
sqlite3 db test.db
|
||||
set ::vfsname [file_control_vfsname db]
|
||||
do_faultsim_test 2 -faults oom* -prep {
|
||||
} -body {
|
||||
file_control_vfsname db
|
||||
}
|
||||
db close
|
||||
sqlite3rbu_destroy_vfs rbu
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,96 @@
|
||||
# 2016 April 20
|
||||
#
|
||||
# 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 contains fault injection tests for RBU vacuum operations.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
source $testdir/malloc_common.tcl
|
||||
set ::testprefix rbufault3
|
||||
|
||||
foreach {fault errlist} {
|
||||
oom-* {
|
||||
{1 SQLITE_NOMEM}
|
||||
{1 SQLITE_IOERR_NOMEM}
|
||||
{1 {SQLITE_NOMEM - out of memory}}
|
||||
}
|
||||
|
||||
ioerr-* {
|
||||
{1 {SQLITE_IOERR - disk I/O error}}
|
||||
{1 SQLITE_IOERR}
|
||||
{1 SQLITE_IOERR_WRITE}
|
||||
{1 SQLITE_IOERR_FSYNC}
|
||||
{1 SQLITE_IOERR_READ}
|
||||
{1 {SQLITE_IOERR - unable to open database: test.db2}}
|
||||
{1 {SQLITE_ERROR - unable to open database: test.db2}}
|
||||
{1 {SQLITE_ERROR - SQL logic error}}
|
||||
}
|
||||
|
||||
cantopen* {
|
||||
{1 {SQLITE_CANTOPEN - unable to open database: test.db2}}
|
||||
{1 {SQLITE_CANTOPEN - unable to open database: test.db2}}
|
||||
{1 {SQLITE_CANTOPEN - unable to open database file}}
|
||||
{1 SQLITE_CANTOPEN}
|
||||
}
|
||||
|
||||
} {
|
||||
|
||||
reset_db
|
||||
do_execsql_test 0 {
|
||||
CREATE TABLE target(x UNIQUE, y, z, PRIMARY KEY(y));
|
||||
INSERT INTO target VALUES(1, 2, 3);
|
||||
INSERT INTO target VALUES(4, 5, 6);
|
||||
INSERT INTO target VALUES(7, 8, 9);
|
||||
CREATE INDEX i1 ON target(z);
|
||||
}
|
||||
faultsim_save_and_close
|
||||
|
||||
do_faultsim_test 1 -faults $fault -prep {
|
||||
faultsim_restore_and_reopen
|
||||
forcedelete test.db2
|
||||
} -body {
|
||||
sqlite3rbu_vacuum rbu test.db test.db2
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
} -test {
|
||||
eval [list faultsim_test_result {0 SQLITE_DONE} {*}$::errlist]
|
||||
}
|
||||
|
||||
do_faultsim_test 2 -faults $fault -prep {
|
||||
faultsim_restore_and_reopen
|
||||
forcedelete test.db2
|
||||
} -body {
|
||||
sqlite3rbu_vacuum rbu test.db test.db2
|
||||
rbu step
|
||||
rbu close
|
||||
} -test {
|
||||
eval [list faultsim_test_result {0 SQLITE_OK} {*}$::errlist]
|
||||
}
|
||||
|
||||
forcedelete test.db2
|
||||
sqlite3rbu_vacuum rbu test.db test.db2
|
||||
rbu step
|
||||
rbu close
|
||||
faultsim_save_and_close
|
||||
|
||||
do_faultsim_test 3 -faults $fault -prep {
|
||||
faultsim_restore_and_reopen
|
||||
} -body {
|
||||
sqlite3rbu_vacuum rbu test.db test.db2
|
||||
rbu step
|
||||
rbu close
|
||||
} -test {
|
||||
eval [list faultsim_test_result {0 SQLITE_OK} {*}$::errlist]
|
||||
}
|
||||
}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,66 @@
|
||||
# 2014 October 22
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
source $testdir/malloc_common.tcl
|
||||
set ::testprefix rbufault4
|
||||
|
||||
for {set tn 1} {1} {incr tn} {
|
||||
reset_db
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1b ON t1(b);
|
||||
CREATE INDEX i1c ON t1(c);
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
}
|
||||
db close
|
||||
|
||||
forcedelete test.db2
|
||||
sqlite3rbu_vacuum rbu test.db test.db2
|
||||
for {set i 0} {$i < $tn} {incr i} { rbu step }
|
||||
set rc [rbu close]
|
||||
if {$rc!="SQLITE_OK"} {
|
||||
if {$rc!="SQLITE_DONE"} {error $rc}
|
||||
break
|
||||
}
|
||||
faultsim_save
|
||||
|
||||
do_faultsim_test $tn -faults oom-t* -prep {
|
||||
faultsim_restore
|
||||
} -body {
|
||||
sqlite3rbu_vacuum rbu test.db test.db2
|
||||
while 1 {
|
||||
set rc [rbu step]
|
||||
if {$rc=="SQLITE_DONE"} break
|
||||
if {$rc!="SQLITE_OK"} { error $rc }
|
||||
}
|
||||
} -test {
|
||||
catch {rbu close}
|
||||
faultsim_test_result {0 {}} {1 SQLITE_NOMEM} {1 SQLITE_IOERR_NOMEM}
|
||||
|
||||
sqlite3rbu_vacuum rbu test.db test.db2
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
set trc [rbu close]
|
||||
if {$trc!="SQLITE_DONE"} { error "Got $trc instead of SQLITE_DONE!" }
|
||||
|
||||
sqlite3 db test.db
|
||||
set rc [db one {PRAGMA integrity_check}]
|
||||
if {$rc!="ok"} { error "Got $rc instead of ok!" }
|
||||
db close
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,131 @@
|
||||
# 2014 August 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 contains tests for the RBU module. More specifically, it
|
||||
# contains tests to ensure that RBU works with FTS tables.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbufts
|
||||
|
||||
ifcapable !fts3 {
|
||||
finish_test
|
||||
return
|
||||
}
|
||||
|
||||
proc step_rbu {target rbu} {
|
||||
while 1 {
|
||||
sqlite3rbu rbu $target $rbu
|
||||
set rc [rbu step]
|
||||
rbu close
|
||||
if {$rc != "SQLITE_OK"} break
|
||||
}
|
||||
set rc
|
||||
}
|
||||
|
||||
proc apply_rbu_update {target sql} {
|
||||
forcedelete rbu.db
|
||||
sqlite3 dbrbu rbu.db
|
||||
execsql $sql dbrbu
|
||||
dbrbu close
|
||||
|
||||
step_rbu $target rbu.db
|
||||
}
|
||||
|
||||
do_execsql_test 1.1.0 {
|
||||
CREATE TABLE t1(i INTEGER PRIMARY KEY, a, b);
|
||||
CREATE VIRTUAL TABLE xx USING fts4(content=t1, a, b);
|
||||
INSERT INTO t1(rowid, a, b) VALUES(10, 'a b c', 'c b a');
|
||||
INSERT INTO t1(rowid, a, b) VALUES(20, 'a b c', 'd e f');
|
||||
INSERT INTO t1(rowid, a, b) VALUES(30, 'd e f', 'a b c');
|
||||
INSERT INTO t1(rowid, a, b) VALUES(40, 'd e f', 'd e f');
|
||||
}
|
||||
|
||||
do_execsql_test 1.1.1 {
|
||||
INSERT INTO xx(xx) VALUES('rebuild');
|
||||
INSERT INTO xx(xx) VALUES('integrity-check');
|
||||
}
|
||||
|
||||
do_test 1.1.2 {
|
||||
apply_rbu_update test.db {
|
||||
CREATE TABLE data_t1(i, a, b, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(20, NULL, NULL, 1); -- delete
|
||||
INSERT INTO data_t1 VALUES(30, 'x y z', NULL, '.x.'); -- update
|
||||
INSERT INTO data_t1 VALUES(50, '1 2 3', 'x y z', 0); -- insert
|
||||
|
||||
CREATE VIEW data0_xx AS
|
||||
SELECT i AS rbu_rowid, a, b,
|
||||
CASE WHEN rbu_control IN (0, 1)
|
||||
THEN rbu_control ELSE substr(rbu_control, 2) END AS rbu_control
|
||||
FROM data_t1;
|
||||
}
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 1.1.3 {
|
||||
INSERT INTO xx(xx) VALUES('integrity-check');
|
||||
}
|
||||
|
||||
reset_db
|
||||
do_execsql_test 1.2.1 {
|
||||
CREATE TABLE ccc(addr, text);
|
||||
CREATE VIRTUAL TABLE ccc_fts USING fts4(addr, text, content=ccc);
|
||||
INSERT INTO ccc VALUES('a b c', 'd e f');
|
||||
INSERT INTO ccc VALUES('a b c', 'd e f');
|
||||
INSERT INTO ccc_fts(ccc_fts) VALUES('rebuild');
|
||||
INSERT INTO ccc_fts(ccc_fts) VALUES('integrity-check');
|
||||
}
|
||||
|
||||
do_test 1.2.2 {
|
||||
apply_rbu_update test.db {
|
||||
CREATE TABLE data_ccc(addr, text, rbu_rowid, rbu_control);
|
||||
CREATE VIEW data0_ccc_fts AS SELECT * FROM data_ccc;
|
||||
INSERT INTO data_ccc VALUES(NULL, NULL, 1, 1);
|
||||
INSERT INTO data_ccc VALUES('x y z', NULL, 2, 'x.');
|
||||
INSERT INTO data_ccc VALUES('y y y', '1 1 1', 3, 0);
|
||||
}
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 1.2.3 {
|
||||
INSERT INTO ccc_fts(ccc_fts) VALUES('integrity-check');
|
||||
}
|
||||
do_execsql_test 1.2.4 {
|
||||
SELECT rowid, * FROM ccc_fts;
|
||||
} {2 {x y z} {d e f} 3 {y y y} {1 1 1}}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test the outcome of attempting to delete or update a row within a
|
||||
# contentless FTS table using RBU. An error.
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 3.1 {
|
||||
CREATE VIRTUAL TABLE ft USING fts4(x, content=);
|
||||
INSERT INTO ft(rowid, x) VALUES(1, '1 2 3');
|
||||
INSERT INTO ft(rowid, x) VALUES(2, '4 5 6');
|
||||
}
|
||||
|
||||
do_test 3.2 {
|
||||
list [catch { apply_rbu_update test.db {
|
||||
CREATE TABLE data_ft(x, rbu_rowid, rbu_control);
|
||||
INSERT INTO data_ft VALUES(NULL, 2, 1);
|
||||
} } msg] $msg]
|
||||
} {1 {SQLITE_ERROR - SQL logic error]}}
|
||||
|
||||
do_test 3.3 {
|
||||
list [catch { apply_rbu_update test.db {
|
||||
CREATE TABLE data_ft(x, rbu_rowid, rbu_control);
|
||||
INSERT INTO data_ft VALUES('7 8 9', 1, 'x');
|
||||
} } msg] $msg]
|
||||
} {1 {SQLITE_ERROR - SQL logic error]}}
|
||||
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,176 @@
|
||||
# 2014 August 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbumisc
|
||||
|
||||
proc populate_rbu_db {} {
|
||||
forcedelete rbu.db
|
||||
sqlite3 rbu rbu.db
|
||||
rbu eval {
|
||||
CREATE TABLE data_x1(a, b, c, rbu_control);
|
||||
INSERT INTO data_x1 VALUES(1, 1, 1, 0);
|
||||
INSERT INTO data_x1 VALUES(2, 2, 2, 0);
|
||||
|
||||
CREATE TABLE dat(a, b, c, rbu_control);
|
||||
CREATE TABLE "data x1"(a, b, c, rbu_control);
|
||||
CREATE TABLE datax1(a, b, c, rbu_control);
|
||||
CREATE TABLE data_(a, b, c, rbu_control);
|
||||
|
||||
INSERT INTO "data x1" VALUES(3, 3, 3, 0);
|
||||
INSERT INTO datax1 VALUES(3, 3, 3, 0);
|
||||
INSERT INTO data_ VALUES(3, 3, 3, 0);
|
||||
INSERT INTO dat VALUES(3, 3, 3, 0);
|
||||
}
|
||||
rbu close
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Ensure that RBU is not confused by oddly named tables in an RBU
|
||||
# database.
|
||||
#
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE x1(a, b, c INTEGER PRIMARY KEY);
|
||||
}
|
||||
do_test 1.1 {
|
||||
populate_rbu_db
|
||||
} {}
|
||||
|
||||
do_test 1.2 {
|
||||
step_rbu test.db rbu.db
|
||||
db eval { SELECT * FROM x1 }
|
||||
} {1 1 1 2 2 2}
|
||||
|
||||
do_test 1.3 {
|
||||
db eval { DELETE FROM x1 }
|
||||
sqlite3 rbu rbu.db
|
||||
rbu eval { DELETE FROM rbu_state }
|
||||
rbu close
|
||||
step_rbu test.db rbu.db
|
||||
db eval { SELECT * FROM x1 }
|
||||
} {1 1 1 2 2 2}
|
||||
|
||||
do_test 1.4 {
|
||||
db eval { DELETE FROM x1 }
|
||||
populate_rbu_db
|
||||
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
rbu step
|
||||
rbu close
|
||||
|
||||
forcecopy test.db-oal test.db-wal
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_ERROR - cannot update wal mode database}}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test the effect of a wal file appearing after the target database has
|
||||
# been opened, but before it has been locked.
|
||||
#
|
||||
catch { db close }
|
||||
testvfs tvfs -default 1
|
||||
|
||||
for {set N 1} {$N < 10} {incr N} {
|
||||
reset_db
|
||||
populate_rbu_db
|
||||
do_execsql_test 2.$N.0 {
|
||||
CREATE TABLE x1(a, b, c INTEGER PRIMARY KEY);
|
||||
}
|
||||
|
||||
set nAccessCnt 0
|
||||
do_test 2.$N.1 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
rbu step
|
||||
rbu close
|
||||
} {SQLITE_OK}
|
||||
|
||||
tvfs script xAccess
|
||||
tvfs filter xAccess
|
||||
set nAccessCnt 0
|
||||
proc xAccess {method file args} {
|
||||
global nAccessCnt
|
||||
if {[file tail $file]=="test.db-wal"} {
|
||||
incr nAccessCnt -1
|
||||
if {$nAccessCnt==0} {
|
||||
set fd [open test.db-wal w]
|
||||
puts -nonewline $fd [string repeat 0 2000]
|
||||
close $fd
|
||||
}
|
||||
}
|
||||
return SQLITE_OK
|
||||
}
|
||||
|
||||
foreach r {
|
||||
{1 {SQLITE_ERROR - cannot update wal mode database}}
|
||||
{0 SQLITE_OK}
|
||||
{1 {SQLITE_CANTOPEN - unable to open database file}}
|
||||
} {
|
||||
set RES($r) 1
|
||||
}
|
||||
do_test 2.$N.2 {
|
||||
set ::nAccessCnt $N
|
||||
set res [list [catch {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
rbu close
|
||||
} msg ] $msg]
|
||||
set RES($res)
|
||||
} {1}
|
||||
catch {rbu close}
|
||||
}
|
||||
catch {db close}
|
||||
catch {tvfs delete}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
testvfs tvfs -default 1
|
||||
reset_db
|
||||
populate_rbu_db
|
||||
do_execsql_test 3.0 {
|
||||
CREATE TABLE x1(a, b, c INTEGER PRIMARY KEY);
|
||||
}
|
||||
|
||||
tvfs script xFileControl
|
||||
tvfs filter xFileControl
|
||||
|
||||
proc xFileControl {method file verb args} {
|
||||
if {$verb=="ZIPVFS" && [info exists ::zipvfs_filecontrol]} {
|
||||
return $::zipvfs_filecontrol
|
||||
}
|
||||
return "SQLITE_NOTFOUND"
|
||||
}
|
||||
|
||||
breakpoint
|
||||
foreach {tn ret err} {
|
||||
1 SQLITE_OK 0
|
||||
2 SQLITE_ERROR 1
|
||||
3 SQLITE_NOTFOUND 0
|
||||
4 SQLITE_OMIT 1
|
||||
} {
|
||||
set ::zipvfs_filecontrol $ret
|
||||
do_test 3.$tn.1 {
|
||||
catch {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu step
|
||||
rbu close
|
||||
}
|
||||
} $err
|
||||
}
|
||||
catch {db close}
|
||||
catch {tvfs delete}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,175 @@
|
||||
# 2018 January 11
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
# TESTRUNNER: slow
|
||||
#
|
||||
# This file contains tests of multiple RBU operations running
|
||||
# concurrently within the same process.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbumulti
|
||||
|
||||
db close
|
||||
|
||||
autoinstall_test_functions
|
||||
|
||||
proc build_db {db} {
|
||||
$db eval {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
CREATE INDEX i2 ON t1(c);
|
||||
|
||||
WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<500 )
|
||||
INSERT INTO t1
|
||||
SELECT randomblob(10), randomblob(100), randomblob(100) FROM s;
|
||||
}
|
||||
}
|
||||
|
||||
proc build_rbu {db} {
|
||||
$db eval {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<100 )
|
||||
INSERT INTO data_t1
|
||||
SELECT randomblob(10), randomblob(100), randomblob(100), 0 FROM s;
|
||||
}
|
||||
}
|
||||
|
||||
proc step_rbu2 {bOpenClose openr1 openr2} {
|
||||
|
||||
forcedelete teststate.db1
|
||||
forcedelete teststate.db2
|
||||
|
||||
if {$bOpenClose!=0 && $bOpenClose!=1} { error $bOpenClose }
|
||||
if {$bOpenClose==0} {
|
||||
eval $openr1
|
||||
eval $openr2
|
||||
}
|
||||
|
||||
set b1 0
|
||||
set b2 0
|
||||
|
||||
while {$b1==0 || $b2==0} {
|
||||
if {$bOpenClose==1} {
|
||||
if {$b1==0} { eval $openr1 teststate.db1 }
|
||||
if {$b2==0} { eval $openr2 teststate.db2 }
|
||||
}
|
||||
if {$b1==0} {
|
||||
set rc1 [r1 step]
|
||||
if {$rc1 != "SQLITE_OK"} { set b1 1 }
|
||||
}
|
||||
if {$b2==0} {
|
||||
set rc2 [r2 step]
|
||||
if {$rc2 != "SQLITE_OK"} { set b2 1 }
|
||||
}
|
||||
if {$bOpenClose==1} {
|
||||
if {$b1==0} { r1 close }
|
||||
if {$b2==0} { r2 close }
|
||||
}
|
||||
}
|
||||
|
||||
set rc1 [r1 close]
|
||||
set rc2 [r2 close]
|
||||
|
||||
list $rc1 $rc2
|
||||
}
|
||||
|
||||
|
||||
for {set i 0} {$i<=3} {incr i} {
|
||||
|
||||
if {$i & 0x01} {
|
||||
sqlite3rbu_create_vfs -default myrbu ""
|
||||
}
|
||||
set bOpenClose [expr $i>>1]
|
||||
|
||||
forcedelete test.db
|
||||
forcedelete test.db2
|
||||
forcedelete rbu.db
|
||||
forcedelete rbu.db2
|
||||
|
||||
do_test 1.$i.0 {
|
||||
sqlite3 db test.db
|
||||
sqlite3 db2 test.db2
|
||||
build_db db
|
||||
build_db db2
|
||||
|
||||
sqlite3 rbu1 rbu.db
|
||||
sqlite3 rbu2 rbu.db2
|
||||
|
||||
build_rbu rbu1
|
||||
build_rbu rbu2
|
||||
|
||||
rbu1 close
|
||||
rbu2 close
|
||||
} {}
|
||||
|
||||
set m1 [db eval {SELECT md5sum(a, b, c) FROM t1}]
|
||||
set m2 [db2 eval {SELECT md5sum(a, b, c) FROM t1}]
|
||||
|
||||
do_test 1.$i.1 {
|
||||
step_rbu2 $bOpenClose {
|
||||
sqlite3rbu r1 test.db rbu.db
|
||||
} {
|
||||
sqlite3rbu r2 test.db2 rbu.db2
|
||||
}
|
||||
} {SQLITE_DONE SQLITE_DONE}
|
||||
|
||||
do_execsql_test -db db 1.$i.2.1 { PRAGMA integrity_check } ok
|
||||
do_execsql_test -db db2 1.$i.2.2 { PRAGMA integrity_check } ok
|
||||
|
||||
do_execsql_test -db db 1.$i.3.1 { SELECT md5sum(a, b, c)==$m1 FROM t1 } 0
|
||||
do_execsql_test -db db2 1.$i.3.2 { SELECT md5sum(a, b, c)==$m2 FROM t1 } 0
|
||||
|
||||
catch { db close }
|
||||
catch { db2 close }
|
||||
#-----------------------------------------------------------------------
|
||||
forcedelete test.db2
|
||||
forcedelete test.db
|
||||
forcedelete rbu.db2
|
||||
|
||||
do_test 1.$i.4 {
|
||||
sqlite3 db test.db
|
||||
sqlite3 db2 test.db2
|
||||
build_db db
|
||||
build_db db2
|
||||
sqlite3 rbu2 rbu.db2
|
||||
build_rbu rbu2
|
||||
rbu2 close
|
||||
} {}
|
||||
|
||||
set m1 [db eval {SELECT md5sum(a, b, c) FROM t1}]
|
||||
set m2 [db2 eval {SELECT md5sum(a, b, c) FROM t1}]
|
||||
|
||||
do_test 1.$i.5 {
|
||||
step_rbu2 $bOpenClose {
|
||||
sqlite3rbu_vacuum r1 test.db
|
||||
} {
|
||||
sqlite3rbu r2 test.db2 rbu.db2
|
||||
}
|
||||
} {SQLITE_DONE SQLITE_DONE}
|
||||
|
||||
do_execsql_test -db db 1.$i.6.1 { SELECT md5sum(a, b, c)==$m1 FROM t1 } 1
|
||||
do_execsql_test -db db2 1.$i.6.2 { SELECT md5sum(a, b, c)==$m2 FROM t1 } 0
|
||||
|
||||
do_execsql_test -db db 1.$i.7.1 { PRAGMA integrity_check } ok
|
||||
do_execsql_test -db db2 1.$i.7.2 { PRAGMA integrity_check } ok
|
||||
|
||||
catch { db close }
|
||||
catch { db2 close }
|
||||
if {$i & 0x01} {
|
||||
sqlite3rbu_destroy_vfs myrbu
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,98 @@
|
||||
# 2019 April 11
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbupartial
|
||||
|
||||
db close
|
||||
|
||||
foreach {tn without_rowid a b c d} {
|
||||
1 "" a b c d
|
||||
2 "WITHOUT ROWID" aaa bbb ccc ddd
|
||||
3 "WITHOUT ROWID" "\"hello\"" {"one'two"} {[c]} ddd
|
||||
4 "WITHOUT ROWID" {`a b`} {"one'two"} {[c c c]} ddd
|
||||
5 "" a b c {"d""d"}
|
||||
6 "" {'one''two'} b {"c""c"} {"d""d"}
|
||||
} {
|
||||
eval [string map [list \
|
||||
%WITHOUT_ROWID% $without_rowid %A% $a %B% $b %C% $c %D% $d
|
||||
] {
|
||||
reset_db
|
||||
do_execsql_test $tn.1.0 {
|
||||
CREATE TABLE t1(%A% PRIMARY KEY, %B%, %C%, %D%) %WITHOUT_ROWID% ;
|
||||
CREATE INDEX i1b ON t1(%B%);
|
||||
CREATE INDEX i1b2 ON t1(%B%) WHERE %C%<5;
|
||||
CREATE INDEX i1b3 ON t1(%B%) WHERE %C%>=5;
|
||||
|
||||
CREATE INDEX i1c ON t1(%C%);
|
||||
CREATE INDEX i1c2 ON t1(%C%) WHERE %C% IS NULL;
|
||||
CREATE INDEX i1c3 ON t1(%C%) WHERE %C% IS NOT NULL;
|
||||
|
||||
CREATE INDEX i1c4 ON t1(%C%) WHERE %D% < 'd';
|
||||
CREATE INDEX i1c5 ON t1(
|
||||
%C% -- for (c = ... expressions
|
||||
) WHERE %D% < 'd';
|
||||
CREATE INDEX i1c6 ON t1(
|
||||
%C% /* Again, for (c=... expr */, %D%
|
||||
) WHERE %D% < 'd';
|
||||
|
||||
CREATE INDEX i1c7 ON t1(
|
||||
%C% /* As before, for (c=... "expr */) WHERE %D% < 'd';
|
||||
}
|
||||
|
||||
do_execsql_test $tn.1.1 {
|
||||
INSERT INTO t1 VALUES(0, NULL, NULL, 'a');
|
||||
INSERT INTO t1 VALUES(1, 2, 3, 'b');
|
||||
INSERT INTO t1 VALUES(4, 5, 6, 'c');
|
||||
INSERT INTO t1 VALUES(7, 8, 9, 'd');
|
||||
}
|
||||
|
||||
forcedelete rbu.db
|
||||
do_test $tn.1.2 {
|
||||
sqlite3 rbu rbu.db
|
||||
rbu eval {
|
||||
CREATE TABLE data_t1(%A%, %B%, %C%, %D%, rbu_control);
|
||||
|
||||
INSERT INTO data_t1 VALUES(10, 11, 12, 'e', 0);
|
||||
INSERT INTO data_t1 VALUES(13, 14, NULL, 'f', 0);
|
||||
|
||||
INSERT INTO data_t1 VALUES(0, NULL, NULL, NULL, 1);
|
||||
INSERT INTO data_t1 VALUES(4, NULL, NULL, NULL, 1);
|
||||
|
||||
INSERT INTO data_t1 VALUES(7, NULL, 4, NULL, '..x.');
|
||||
INSERT INTO data_t1 VALUES(1, 10, NULL, NULL, '.xx.');
|
||||
}
|
||||
rbu close
|
||||
} {}
|
||||
|
||||
do_test $tn.1.3 {
|
||||
run_rbu test.db rbu.db
|
||||
execsql { PRAGMA integrity_check }
|
||||
} {ok}
|
||||
|
||||
do_execsql_test $tn.1.4 {
|
||||
SELECT * FROM t1 ORDER BY %A%;
|
||||
} {
|
||||
1 10 {} b 7 8 4 d 10 11 12 e 13 14 {} f
|
||||
}
|
||||
|
||||
set step 0
|
||||
do_rbu_vacuum_test $tn.1.5 0
|
||||
|
||||
do_test $tn.1.6 {
|
||||
execsql { PRAGMA integrity_check }
|
||||
} {ok}
|
||||
}]
|
||||
}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,81 @@
|
||||
# 2023 January 13
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbupass
|
||||
|
||||
if {[info commands register_demovfs]==""} {
|
||||
finish_test
|
||||
return
|
||||
}
|
||||
|
||||
db close
|
||||
|
||||
register_demovfs
|
||||
sqlite3rbu_create_vfs myvfs demo
|
||||
|
||||
sqlite3 db file:test.db?vfs=myvfs -uri 1
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
SELECT * FROM t1;
|
||||
} {1 2}
|
||||
|
||||
if {[permutation]!="inmemory_journal"} {
|
||||
do_execsql_test 1.1 {
|
||||
PRAGMA journal_mode = wal;
|
||||
} {delete}
|
||||
}
|
||||
|
||||
do_execsql_test 1.2 {
|
||||
SELECT * FROM t1;
|
||||
} {1 2}
|
||||
|
||||
do_test 1.3 {
|
||||
forcedelete rbu.db
|
||||
sqlite3 rbu rbu.db
|
||||
rbu eval {
|
||||
CREATE TABLE data_t1(a, b, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(2, 4, 0);
|
||||
}
|
||||
rbu close
|
||||
} {}
|
||||
|
||||
do_test 1.4 {
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
} {rbu}
|
||||
do_test 1.5 {
|
||||
rbu step
|
||||
} {SQLITE_CANTOPEN}
|
||||
do_test 1.6 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_CANTOPEN - unable to open database file}}
|
||||
|
||||
do_test 1.7 {
|
||||
sqlite3rbu_vacuum rbu test.db
|
||||
} {rbu}
|
||||
do_test 1.8 {
|
||||
rbu step
|
||||
catch { rbu close }
|
||||
} {1}
|
||||
|
||||
do_execsql_test 1.9 {
|
||||
SELECT * FROM t1;
|
||||
} {1 2}
|
||||
|
||||
db close
|
||||
sqlite3rbu_destroy_vfs myvfs
|
||||
unregister_demovfs
|
||||
sqlite3_shutdown
|
||||
finish_test
|
||||
|
||||
@@ -0,0 +1,451 @@
|
||||
# 2016 March 18
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbuprogress
|
||||
|
||||
|
||||
proc create_db_file {filename sql} {
|
||||
forcedelete $filename
|
||||
sqlite3 tmpdb $filename
|
||||
tmpdb eval $sql
|
||||
tmpdb close
|
||||
}
|
||||
|
||||
# Create a simple RBU database. That expects to write to a table:
|
||||
#
|
||||
# CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
#
|
||||
proc create_rbu1 {filename} {
|
||||
create_db_file $filename {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 2, 3, 0);
|
||||
INSERT INTO data_t1 VALUES(2, 'two', 'three', 0);
|
||||
INSERT INTO data_t1 VALUES(3, NULL, 8.2, 0);
|
||||
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data_t1', 3);
|
||||
}
|
||||
return $filename
|
||||
}
|
||||
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
PRAGMA page_size = 4096;
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
}
|
||||
|
||||
do_test 1.1 {
|
||||
create_rbu1 rbu.db
|
||||
sqlite3rbu rbu test.db rbu.db
|
||||
rbu bp_progress
|
||||
} {0 0}
|
||||
do_test 1.2 { rbu step ; rbu bp_progress } {3333 0}
|
||||
do_test 1.3 { rbu step ; rbu bp_progress } {6666 0}
|
||||
do_test 1.4 { rbu step ; rbu bp_progress } {10000 0}
|
||||
do_test 1.5 { rbu step ; rbu bp_progress } {10000 0}
|
||||
do_test 1.6 { rbu step ; rbu bp_progress } {10000 0}
|
||||
do_test 1.7 { rbu step ; rbu bp_progress } {10000 5000}
|
||||
do_test 1.8 { rbu step ; rbu bp_progress } {10000 10000}
|
||||
do_test 1.9 { rbu step ; rbu bp_progress } {10000 10000}
|
||||
|
||||
do_test 1.10 {
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
#
|
||||
proc do_sp_test {tn bReopen target rbu reslist} {
|
||||
uplevel [list do_test $tn [subst -nocommands {
|
||||
if {$bReopen==0} { sqlite3rbu rbu $target $rbu }
|
||||
set res [list]
|
||||
while 1 {
|
||||
if {$bReopen} { sqlite3rbu rbu $target $rbu }
|
||||
set rc [rbu step]
|
||||
if {[set rc] != "SQLITE_OK"} { rbu close ; error "error 1" }
|
||||
lappend res [lindex [rbu bp_progress] 0]
|
||||
if {[lindex [set res] end]==10000} break
|
||||
if {$bReopen} { rbu close }
|
||||
}
|
||||
if {[set res] != [list $reslist]} {
|
||||
rbu close
|
||||
error "1. reslist incorrect (expect=$reslist got=[set res])"
|
||||
}
|
||||
|
||||
# One step to clean up the temporary tables used to update the only
|
||||
# target table in the rbu database. And one more to move the *-oal
|
||||
# file to *-wal. After each of these steps, the progress remains
|
||||
# at "10000 0".
|
||||
#
|
||||
if {[lindex [list $reslist] 0]!=-1} {
|
||||
rbu step
|
||||
set res [rbu bp_progress]
|
||||
if {[set res] != [list 10000 0]} {
|
||||
rbu close
|
||||
error "2. reslist incorrect (expect=10000 0 got=[set res])"
|
||||
}
|
||||
}
|
||||
|
||||
rbu step
|
||||
set res [rbu bp_progress]
|
||||
if {[set res] != [list 10000 0]} {
|
||||
rbu close
|
||||
error "3. reslist incorrect (expect=10000 0 got=[set res])"
|
||||
}
|
||||
|
||||
# Do the checkpoint.
|
||||
while {[rbu step]=="SQLITE_OK"} {
|
||||
foreach {a b} [rbu bp_progress] {}
|
||||
if {[set a]!=10000 || [set b]<=0 || [set b]>10000} {
|
||||
rbu close
|
||||
error "4. reslist incorrect (expect=10000 1..10000 got=[set a] [set b])"
|
||||
}
|
||||
}
|
||||
|
||||
set res [rbu bp_progress]
|
||||
if {[set res] != [list 10000 10000]} {
|
||||
rbu close
|
||||
error "5. reslist is incorrect (expect=10000 10000 got=[set res])"
|
||||
}
|
||||
|
||||
rbu close
|
||||
}] {SQLITE_DONE}]
|
||||
}
|
||||
|
||||
foreach {bReopen} { 0 1 } {
|
||||
reset_db
|
||||
do_test 2.$bReopen.1.0 {
|
||||
execsql {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
}
|
||||
create_db_file rbu.db {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(4, 4, 4, 0);
|
||||
INSERT INTO data_t1 VALUES(5, 5, 5, 0);
|
||||
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data_t1', 2);
|
||||
}
|
||||
} {}
|
||||
do_sp_test 2.$bReopen.1.1 $bReopen test.db rbu.db {5000 10000}
|
||||
|
||||
reset_db
|
||||
do_test 2.$bReopen.2.0 {
|
||||
execsql { CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c) }
|
||||
create_rbu1 rbu.db
|
||||
} {rbu.db}
|
||||
do_sp_test 2.$bReopen.2.1 $bReopen test.db rbu.db {3333 6666 10000}
|
||||
|
||||
reset_db
|
||||
do_test 2.$bReopen.3.0 {
|
||||
execsql {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
INSERT INTO t1 VALUES(1, 1, 1);
|
||||
INSERT INTO t1 VALUES(2, 2, 2);
|
||||
INSERT INTO t1 VALUES(3, 3, 3);
|
||||
}
|
||||
create_db_file rbu.db {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(4, 4, 4, 0);
|
||||
INSERT INTO data_t1 VALUES(2, NULL, NULL, 1);
|
||||
INSERT INTO data_t1 VALUES(5, NULL, NULL, 1);
|
||||
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data_t1', 3);
|
||||
}
|
||||
} {}
|
||||
do_sp_test 2.$bReopen.3.1 $bReopen test.db rbu.db {1666 3333 6000 8000 10000}
|
||||
|
||||
reset_db
|
||||
do_test 2.$bReopen.4.0 {
|
||||
execsql {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
INSERT INTO t1 VALUES(1, 1, 1);
|
||||
INSERT INTO t1 VALUES(2, 2, 2);
|
||||
INSERT INTO t1 VALUES(3, 3, 3);
|
||||
}
|
||||
create_db_file rbu.db {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(2, 4, 4, '.xx');
|
||||
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data_t1', 1);
|
||||
}
|
||||
} {}
|
||||
do_sp_test 2.$bReopen.4.1 $bReopen test.db rbu.db {3333 6666 10000}
|
||||
|
||||
reset_db
|
||||
do_test 2.$bReopen.5.0 {
|
||||
execsql {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
INSERT INTO t1 VALUES(1, 1, 1);
|
||||
INSERT INTO t1 VALUES(2, 2, 2);
|
||||
INSERT INTO t1 VALUES(3, 3, 3);
|
||||
}
|
||||
create_db_file rbu.db {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(4, NULL, 4, '.xx');
|
||||
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data_t1', 1);
|
||||
}
|
||||
} {}
|
||||
do_sp_test 2.$bReopen.5.1 $bReopen test.db rbu.db {10000}
|
||||
|
||||
reset_db
|
||||
do_test 2.$bReopen.6.0 {
|
||||
execsql {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
INSERT INTO t1 VALUES(1, 1, 1);
|
||||
INSERT INTO t1 VALUES(2, 2, 2);
|
||||
INSERT INTO t1 VALUES(3, 3, 3);
|
||||
}
|
||||
create_db_file rbu.db {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(4, 4, 4, 0);
|
||||
INSERT INTO data_t1 VALUES(2, NULL, NULL, 1);
|
||||
INSERT INTO data_t1 VALUES(5, NULL, NULL, 1);
|
||||
}
|
||||
} {}
|
||||
do_sp_test 2.$bReopen.6.1 $bReopen test.db rbu.db {-1 -1 -1 -1 -1 10000}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# The following tests verify that the API works when resuming an update
|
||||
# during the incremental checkpoint stage.
|
||||
#
|
||||
proc do_phase2_test {tn bReopen target rbu nStep} {
|
||||
uplevel [list do_test $tn [subst -nocommands {
|
||||
|
||||
# Build the OAL/WAL file:
|
||||
sqlite3rbu rbu $target $rbu
|
||||
while {[lindex [rbu bp_progress] 0]<10000} {
|
||||
set rc [rbu step]
|
||||
if {"SQLITE_OK" != [set rc]} { rbu close }
|
||||
}
|
||||
|
||||
# Clean up the temp tables and move the *-oal file to *-wal.
|
||||
rbu step
|
||||
rbu step
|
||||
|
||||
for {set i 0} {[set i] < $nStep} {incr i} {
|
||||
if {$bReopen} {
|
||||
rbu close
|
||||
sqlite3rbu rbu $target $rbu
|
||||
}
|
||||
rbu step
|
||||
set res [rbu bp_progress]
|
||||
set expect [expr (1 + [set i]) * 10000 / $nStep]
|
||||
if {[lindex [set res] 1] != [set expect]} {
|
||||
error "Have [set res], expected 10000 [set expect]"
|
||||
}
|
||||
}
|
||||
|
||||
set rc [rbu step]
|
||||
if {[set rc] != "SQLITE_DONE"} {
|
||||
error "Have [set rc], expected SQLITE_DONE"
|
||||
}
|
||||
|
||||
rbu close
|
||||
}] {SQLITE_DONE}]
|
||||
}
|
||||
|
||||
foreach bReopen {0 1} {
|
||||
do_test 3.$bReopen.1.0 {
|
||||
reset_db
|
||||
execsql {
|
||||
PRAGMA page_size = 4096;
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
|
||||
CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
|
||||
CREATE TABLE t3(a INTEGER PRIMARY KEY, b);
|
||||
CREATE TABLE t4(a INTEGER PRIMARY KEY, b);
|
||||
}
|
||||
create_db_file rbu.db {
|
||||
CREATE TABLE data_t1(a, b, rbu_control);
|
||||
CREATE TABLE data_t2(a, b, rbu_control);
|
||||
CREATE TABLE data_t3(a, b, rbu_control);
|
||||
CREATE TABLE data_t4(a, b, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(1, 2, 0);
|
||||
INSERT INTO data_t2 VALUES(1, 2, 0);
|
||||
INSERT INTO data_t3 VALUES(1, 2, 0);
|
||||
INSERT INTO data_t4 VALUES(1, 2, 0);
|
||||
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data_t1', 1);
|
||||
INSERT INTO rbu_count VALUES('data_t2', 1);
|
||||
INSERT INTO rbu_count VALUES('data_t3', 1);
|
||||
INSERT INTO rbu_count VALUES('data_t4', 1);
|
||||
}
|
||||
} {}
|
||||
do_phase2_test 3.$bReopen.1.1 $bReopen test.db rbu.db 5
|
||||
}
|
||||
|
||||
|
||||
foreach {bReopen} { 0 1 } {
|
||||
foreach {tn tbl} {
|
||||
ipk { CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c) }
|
||||
wr { CREATE TABLE t1(a INT PRIMARY KEY, b, c) WITHOUT ROWID }
|
||||
pk { CREATE TABLE t1(a INT PRIMARY KEY, b, c) }
|
||||
} {
|
||||
|
||||
foreach {tn2 rbusql r1 r3} {
|
||||
1 {
|
||||
CREATE TABLE data0_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data0_t1 VALUES(15, 15, 15, 0);
|
||||
INSERT INTO data0_t1 VALUES(20, 20, 20, 0);
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data0_t1', 2);
|
||||
}
|
||||
{2500 5000 7500 10000}
|
||||
{1666 3333 5000 6666 8333 10000}
|
||||
|
||||
2 {
|
||||
CREATE TABLE data0_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data0_t1 VALUES(10, 10, 10, 2);
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data0_t1', 1);
|
||||
}
|
||||
{3333 6666 10000}
|
||||
{2000 4000 6000 8000 10000}
|
||||
|
||||
3 {
|
||||
CREATE TABLE data0_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data0_t1 VALUES(7, 7, 7, 2);
|
||||
INSERT INTO data0_t1 VALUES(10, 10, 10, 2);
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data0_t1', 2);
|
||||
}
|
||||
{2500 4000 6000 8000 10000}
|
||||
{1666 2500 3750 5000 6250 7500 8750 10000}
|
||||
|
||||
} {
|
||||
|
||||
reset_db ; execsql $tbl
|
||||
do_test 4.$tn.$bReopen.$tn2.0 {
|
||||
execsql {
|
||||
CREATE INDEX t1c ON t1(c);
|
||||
INSERT INTO t1 VALUES(1, 1, 1);
|
||||
INSERT INTO t1 VALUES(5, 5, 5);
|
||||
INSERT INTO t1 VALUES(10, 10, 10);
|
||||
}
|
||||
create_db_file rbu.db $rbusql
|
||||
} {}
|
||||
|
||||
set R(ipk) $r1
|
||||
set R(wr) $r1
|
||||
set R(pk) $r3
|
||||
do_sp_test 4.$tn.$bReopen.$tn2.1 $bReopen test.db rbu.db $R($tn)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
foreach {bReopen} { 0 1 } {
|
||||
foreach {tn tbl} {
|
||||
nopk {
|
||||
CREATE TABLE t1(a, b, c);
|
||||
CREATE INDEX t1c ON t1(c);
|
||||
}
|
||||
vtab {
|
||||
CREATE VIRTUAL TABLE t1 USING fts5(a, b, c);
|
||||
}
|
||||
} {
|
||||
|
||||
if {$tn=="vtab"} { ifcapable !fts5 break }
|
||||
|
||||
foreach {tn2 rbusql r1 r2} {
|
||||
1 {
|
||||
CREATE TABLE data0_t1(a, b, c, rbu_rowid, rbu_control);
|
||||
INSERT INTO data0_t1 VALUES(15, 15, 15, 4, 0);
|
||||
INSERT INTO data0_t1 VALUES(20, 20, 20, 5, 0);
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data0_t1', 2);
|
||||
}
|
||||
{2500 5000 7500 10000}
|
||||
{5000 10000}
|
||||
|
||||
2 {
|
||||
CREATE TABLE data0_t1(rbu_rowid, a, b, c, rbu_control);
|
||||
INSERT INTO data0_t1 VALUES(0, 7, 7, 7, 2);
|
||||
INSERT INTO data0_t1 VALUES(2, 10, 10, 10, 2);
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data0_t1', 2);
|
||||
}
|
||||
{2500 4000 6000 8000 10000}
|
||||
{5000 10000}
|
||||
|
||||
3 {
|
||||
CREATE TABLE data0_t1(rbu_rowid, a, b, c, rbu_control);
|
||||
INSERT INTO data0_t1 VALUES(1, NULL, NULL, NULL, 1);
|
||||
INSERT INTO data0_t1 VALUES(2, NULL, NULL, 7, '..x');
|
||||
CREATE TABLE rbu_count(tbl, cnt);
|
||||
INSERT INTO rbu_count VALUES('data0_t1', 2);
|
||||
}
|
||||
{2500 4000 6000 8000 10000}
|
||||
{5000 10000}
|
||||
} {
|
||||
|
||||
reset_db ; execsql $tbl
|
||||
do_test 5.$tn.$bReopen.$tn2.0 {
|
||||
execsql {
|
||||
INSERT INTO t1 VALUES(1, 1, 1);
|
||||
INSERT INTO t1 VALUES(5, 5, 5);
|
||||
INSERT INTO t1 VALUES(10, 10, 10);
|
||||
}
|
||||
create_db_file rbu.db $rbusql
|
||||
} {}
|
||||
|
||||
set R(nopk) $r1
|
||||
set R(vtab) $r2
|
||||
do_sp_test 5.$tn.$bReopen.$tn2.1 $bReopen test.db rbu.db $R($tn)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that sqlite3_bp_progress() works with an RBU vacuum if there
|
||||
# is an rbu_count table in the db being vacuumed.
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 6.0 {
|
||||
CREATE TABLE t1(a, b, c);
|
||||
CREATE INDEX i1 ON t1(a);
|
||||
CREATE INDEX i2 ON t1(b);
|
||||
WITH s(i) AS (
|
||||
SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<100
|
||||
)
|
||||
INSERT INTO t1 SELECT i, i, i FROM s;
|
||||
CREATE TABLE rbu_count(tbl TEXT PRIMARY KEY, cnt INTEGER) WITHOUT ROWID;
|
||||
INSERT INTO rbu_count VALUES('t1', (SELECT count(*) FROM t1));
|
||||
INSERT INTO rbu_count VALUES('rbu_count', 2);
|
||||
}
|
||||
|
||||
forcedelete state.db
|
||||
do_test 6.1 {
|
||||
set maxA 0
|
||||
set maxB 0
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
while {[rbu step]=="SQLITE_OK"} {
|
||||
foreach {a b} [rbu bp_progress] {
|
||||
if {$a > $maxA} { set maxA $a }
|
||||
if {$b > $maxB} { set maxB $b }
|
||||
}
|
||||
}
|
||||
list [rbu close] $maxA $maxB
|
||||
} {SQLITE_DONE 10000 10000}
|
||||
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,55 @@
|
||||
# 2022 November 07
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rburename
|
||||
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a, b);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
INSERT INTO t1 VALUES(3, 4);
|
||||
INSERT INTO t1 VALUES(5, 6);
|
||||
}
|
||||
|
||||
forcedelete test.db-vacuum
|
||||
|
||||
proc my_rename {old new} {
|
||||
lappend ::my_rename_calls [list [file tail $old] [file tail $new]]
|
||||
file rename $old $new
|
||||
}
|
||||
|
||||
do_test 1.1 {
|
||||
sqlite3rbu_vacuum rbu test.db
|
||||
rbu rename_handler my_rename
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
} SQLITE_DONE
|
||||
|
||||
do_test 1.2 {
|
||||
set ::my_rename_calls
|
||||
} {{test.db-oal test.db-wal}}
|
||||
|
||||
proc my_rename {old new} {
|
||||
error "something went wrong"
|
||||
}
|
||||
|
||||
do_test 1.3 {
|
||||
sqlite3rbu_vacuum rbu test.db
|
||||
rbu rename_handler my_rename
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 SQLITE_IOERR}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,256 @@
|
||||
# 2017 January 13
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
# TESTRUNNER: slow
|
||||
#
|
||||
# This file contains tests for resumption of RBU operations in the
|
||||
# case where the previous RBU process crashed.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rburesume
|
||||
|
||||
forcedelete test.db-shm test.db-oal
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
CREATE INDEX t1a ON t1(a);
|
||||
CREATE INDEX t1b ON t1(b);
|
||||
CREATE INDEX t1c ON t1(c);
|
||||
WITH s(i) AS (
|
||||
VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<50
|
||||
)
|
||||
INSERT INTO t1 SELECT randomblob(50), randomblob(75), randomblob(100) FROM s;
|
||||
}
|
||||
db_save_and_close
|
||||
|
||||
do_test 1.1 {
|
||||
list [file exists test.db] \
|
||||
[file exists test.db-wal] \
|
||||
[file exists test.db-shm] \
|
||||
[file exists test.db-oal]
|
||||
} {1 0 0 0}
|
||||
|
||||
# Each iteration of the following loop:
|
||||
#
|
||||
# 1. Restores the db to the state it was in following test case 1.0
|
||||
# 2. Opens an RBU vacuum and steps it $n times.
|
||||
# 3. Closes the RBU vacuum handled opened in (2).
|
||||
# 4. Opens a second RBU vacuum handle, resumes and completes the vacuum op.
|
||||
#
|
||||
# The loop runs until $n is large enough that step (2) vacuums the entire
|
||||
# database.
|
||||
#
|
||||
for {set n 1} {$n < 5000} {incr n} {
|
||||
db_restore
|
||||
forcedelete state.db
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
for {set i 0} {$i<$n} {incr i} {
|
||||
set rc [rbu step]
|
||||
if {$rc == "SQLITE_DONE"} break
|
||||
}
|
||||
rbu close
|
||||
if {$rc == "SQLITE_DONE"} break
|
||||
|
||||
do_test 1.2.$n.1 {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 1.2.$n.2 {
|
||||
sqlite3 db2 test.db
|
||||
db2 eval {
|
||||
SELECT count(*) FROM t1;
|
||||
PRAGMA integrity_check;
|
||||
}
|
||||
} {50 ok}
|
||||
db2 close
|
||||
}
|
||||
|
||||
# Each iteration of this loop:
|
||||
#
|
||||
# 1. Restores the db to the state it was in following test case 1.0
|
||||
# 2. Opens an RBU vacuum and steps it $n times.
|
||||
# 3. Takes a copy of all database files and the state db.
|
||||
# 4. Opens a second RBU vacuum handle on the copy, resumes and completes the
|
||||
# vacuum op.
|
||||
#
|
||||
# The loop runs until $n is large enough that step (2) vacuums the entire
|
||||
# database.
|
||||
#
|
||||
for {set n 1} {$n < 5000} {incr n} {
|
||||
db_restore
|
||||
forcedelete state.db state.db-shm state.db-oal state.db-wal
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
for {set i 0} {$i<$n} {incr i} {
|
||||
set rc [rbu step]
|
||||
if {$rc == "SQLITE_DONE"} break
|
||||
}
|
||||
if {$rc == "SQLITE_DONE"} {
|
||||
rbu close
|
||||
break
|
||||
}
|
||||
|
||||
foreach f {test.db test.db-oal test.db-wal test.db-vacuum} {
|
||||
set f2 [string map [list test.db test.db2] $f]
|
||||
if {[file exists $f]} {
|
||||
forcecopy $f $f2
|
||||
} else {
|
||||
forcedelete $f2
|
||||
}
|
||||
}
|
||||
forcecopy state.db state.db2
|
||||
rbu close
|
||||
|
||||
do_test 1.3.$n.1 {
|
||||
sqlite3rbu_vacuum rbu test.db2 state.db2
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 1.3.$n.2 {
|
||||
sqlite3 db2 test.db2
|
||||
db2 eval {
|
||||
SELECT count(*) FROM t1;
|
||||
PRAGMA integrity_check;
|
||||
}
|
||||
} {50 ok}
|
||||
db2 close
|
||||
}
|
||||
|
||||
# Each iteration of this loop:
|
||||
#
|
||||
# 1. Restores the db to the state it was in following test case 1.0
|
||||
# 2. Opens an RBU vacuum and steps it 10 times. Then closes it.
|
||||
# 2. Opens an RBU vacuum and steps it $n times.
|
||||
# 3. Takes a copy of all database files and the state db.
|
||||
# 4. Opens a second RBU vacuum handle on the copy, resumes and completes the
|
||||
# vacuum op.
|
||||
#
|
||||
# The loop runs until $n is large enough that step (3) vacuums the entire
|
||||
# database.
|
||||
#
|
||||
for {set n 1} {$n < 5000} {incr n} {
|
||||
db_restore
|
||||
forcedelete state.db state.db-shm state.db-oal state.db-wal
|
||||
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
for {set i 0} {$i<10} {incr i} {
|
||||
rbu step
|
||||
}
|
||||
rbu close
|
||||
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
for {set i 0} {$i<$n} {incr i} {
|
||||
set rc [rbu step]
|
||||
if {$rc == "SQLITE_DONE"} break
|
||||
}
|
||||
if {$rc == "SQLITE_DONE"} {
|
||||
rbu close
|
||||
break
|
||||
}
|
||||
|
||||
foreach f {test.db test.db-oal test.db-wal test.db-vacuum} {
|
||||
set f2 [string map [list test.db test.db2] $f]
|
||||
if {[file exists $f]} {
|
||||
forcecopy $f $f2
|
||||
} else {
|
||||
forcedelete $f2
|
||||
}
|
||||
}
|
||||
forcecopy state.db state.db2
|
||||
rbu close
|
||||
|
||||
do_test 1.4.$n.1 {
|
||||
sqlite3rbu_vacuum rbu test.db2 state.db2
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 1.4.$n.2 {
|
||||
sqlite3 db2 test.db2
|
||||
db2 eval {
|
||||
SELECT count(*) FROM t1;
|
||||
PRAGMA integrity_check;
|
||||
}
|
||||
} {50 ok}
|
||||
db2 close
|
||||
}
|
||||
|
||||
forcedelete rbu.db
|
||||
do_test 2.0 {
|
||||
sqlite3 db2 rbu.db
|
||||
db2 eval {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
WITH s(i) AS (
|
||||
VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<10
|
||||
)
|
||||
INSERT INTO data_t1
|
||||
SELECT randomblob(50), randomblob(75), randomblob(100), 0 FROM s;
|
||||
}
|
||||
db2 close
|
||||
} {}
|
||||
|
||||
# Each iteration of this loop:
|
||||
#
|
||||
# 1. Restores the db to the state it was in following test case 1.0
|
||||
# 2. Opens an RBU handle to apply the RBU update created in test case 2.0.
|
||||
# 3. Steps the RBU handle $n times.
|
||||
# 4. Takes a copy of all database files and the state db.
|
||||
# 5. Opens a second RBU handle on the copy, resumes and completes the
|
||||
# RBU op. Checks it worked as expected.
|
||||
#
|
||||
# The loop runs until $n is large enough that step (3) applies the entire
|
||||
# update.
|
||||
#
|
||||
for {set n 1} {$n < 5000} {incr n} {
|
||||
db_restore
|
||||
forcedelete state.db state.db-shm state.db-oal state.db-wal
|
||||
sqlite3rbu rbu test.db rbu.db state.db
|
||||
|
||||
for {set i 0} {$i<$n} {incr i} {
|
||||
set rc [rbu step]
|
||||
if {$rc == "SQLITE_DONE"} break
|
||||
}
|
||||
if {$rc == "SQLITE_DONE"} {
|
||||
rbu close
|
||||
break
|
||||
}
|
||||
|
||||
foreach f {test.db test.db-oal test.db-wal test.db-vacuum} {
|
||||
set f2 [string map [list test.db test.db2] $f]
|
||||
if {[file exists $f]} {
|
||||
forcecopy $f $f2
|
||||
} else {
|
||||
forcedelete $f2
|
||||
}
|
||||
}
|
||||
forcecopy state.db state.db2
|
||||
rbu close
|
||||
|
||||
do_test 2.$n.1 {
|
||||
sqlite3rbu rbu test.db2 rbu.db state.db2
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 2.$n.2 {
|
||||
sqlite3 db2 test.db2
|
||||
db2 eval {
|
||||
SELECT count(*) FROM t1;
|
||||
PRAGMA integrity_check;
|
||||
}
|
||||
} {60 ok}
|
||||
db2 close
|
||||
}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,102 @@
|
||||
# 2015 August 14
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbusave
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
CREATE TABLE t2(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
CREATE INDEX i2 ON t2(c, b);
|
||||
|
||||
INSERT INTO t1 VALUES(1, 1, 1);
|
||||
INSERT INTO t1 VALUES(2, 2, 2);
|
||||
INSERT INTO t1 VALUES(3, 3, 3);
|
||||
|
||||
INSERT INTO t2 VALUES(1, 1, 1);
|
||||
INSERT INTO t2 VALUES(2, 2, 2);
|
||||
INSERT INTO t2 VALUES(3, 3, 3);
|
||||
}
|
||||
|
||||
do_test 1.1 {
|
||||
forcedelete test.db2
|
||||
sqlite3 db2 test.db2
|
||||
db2 eval {
|
||||
CREATE TABLE data_t1(a, b, c, rbu_control);
|
||||
INSERT INTO data_t1 VALUES(4, 4, 4, 0);
|
||||
INSERT INTO data_t1 VALUES(2, NULL, NULL, 1);
|
||||
INSERT INTO data_t1 VALUES(1, 'one', NULL, '.x.');
|
||||
|
||||
CREATE TABLE data_t2(a, b, c, rbu_control);
|
||||
INSERT INTO data_t2 VALUES(4, 4, 4, 0);
|
||||
INSERT INTO data_t2 VALUES(2, NULL, NULL, 1);
|
||||
INSERT INTO data_t2 VALUES(1, 'one', NULL, '.x.');
|
||||
}
|
||||
} {}
|
||||
|
||||
proc test_to_bak {} {
|
||||
foreach f {
|
||||
test.db test.db-wal test.db-oal test.db-journal
|
||||
test.db2 test.db2-wal test.db2-oal test.db2-journal
|
||||
} {
|
||||
set t [string map {test bak} $f]
|
||||
forcedelete $t
|
||||
if {[file exists $f]} { forcecopy $f $t }
|
||||
}
|
||||
}
|
||||
|
||||
do_test 1.2 {
|
||||
test_to_bak
|
||||
sqlite3rbu rrr bak.db bak.db2
|
||||
set nStep 0
|
||||
while {[rrr step]=="SQLITE_OK"} {incr nStep}
|
||||
set res2 [rrr close]
|
||||
} {SQLITE_DONE}
|
||||
|
||||
|
||||
sqlite3rbu rbu test.db test.db2
|
||||
set res "SQLITE_OK"
|
||||
for {set i 1} {$res=="SQLITE_OK"} {incr i} {
|
||||
set res [rbu step]
|
||||
|
||||
do_test 1.3.$i.1 {
|
||||
rbu savestate
|
||||
test_to_bak
|
||||
sqlite3rbu rrr bak.db bak.db2
|
||||
set nRem 0
|
||||
while {[rrr step]=="SQLITE_OK"} {incr nRem}
|
||||
set res2 [rrr close]
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 1.3.$i.3 { expr $nRem+$i } [expr {$nStep + ($res=="SQLITE_DONE")}]
|
||||
|
||||
do_test 1.3.$i.3 {
|
||||
sqlite3 bak bak.db
|
||||
bak eval {
|
||||
SELECT * FROM t1;
|
||||
SELECT * FROM t2;
|
||||
}
|
||||
} {1 one 1 3 3 3 4 4 4 1 one 1 3 3 3 4 4 4}
|
||||
|
||||
bak close
|
||||
}
|
||||
|
||||
do_test 1.4 { rbu close } {SQLITE_DONE}
|
||||
|
||||
do_execsql_test 1.5 {
|
||||
SELECT * FROM t1;
|
||||
SELECT * FROM t2;
|
||||
} {1 one 1 3 3 3 4 4 4 1 one 1 3 3 3 4 4 4}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,93 @@
|
||||
# 2018 April 28
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbusplit
|
||||
|
||||
db close
|
||||
|
||||
autoinstall_test_functions
|
||||
|
||||
proc build_db {db} {
|
||||
$db eval {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
CREATE TABLE t2(a PRIMARY KEY, b, c);
|
||||
|
||||
CREATE INDEX t1c ON t1(c);
|
||||
}
|
||||
}
|
||||
|
||||
proc build_rbu {filename} {
|
||||
forcedelete $filename
|
||||
sqlite3 dbRbu $filename
|
||||
dbRbu eval {
|
||||
CREATE TABLE data0_t1(a, b, c, rbu_control);
|
||||
CREATE TABLE data1_t1(a, b, c, rbu_control);
|
||||
CREATE TABLE data2_t1(a, b, c, rbu_control);
|
||||
CREATE TABLE data3_t1(a, b, c, rbu_control);
|
||||
|
||||
CREATE TABLE data_t2(a, b, c, rbu_control);
|
||||
|
||||
INSERT INTO data0_t1 VALUES(1, 1, 1, 0);
|
||||
INSERT INTO data0_t1 VALUES(2, 2, 2, 0);
|
||||
INSERT INTO data0_t1 VALUES(3, 3, 3, 0);
|
||||
INSERT INTO data0_t1 VALUES(4, 4, 4, 0);
|
||||
INSERT INTO data1_t1 VALUES(5, 5, 5, 0);
|
||||
INSERT INTO data1_t1 VALUES(6, 6, 6, 0);
|
||||
INSERT INTO data1_t1 VALUES(7, 7, 7, 0);
|
||||
INSERT INTO data1_t1 VALUES(8, 8, 8, 0);
|
||||
INSERT INTO data3_t1 VALUES(9, 9, 9, 0);
|
||||
|
||||
INSERT INTO data_t2 VALUES(1, 1, 1, 0);
|
||||
INSERT INTO data_t2 VALUES(2, 2, 2, 0);
|
||||
INSERT INTO data_t2 VALUES(3, 3, 3, 0);
|
||||
INSERT INTO data_t2 VALUES(4, 4, 4, 0);
|
||||
INSERT INTO data_t2 VALUES(5, 5, 5, 0);
|
||||
INSERT INTO data_t2 VALUES(6, 6, 6, 0);
|
||||
INSERT INTO data_t2 VALUES(7, 7, 7, 0);
|
||||
INSERT INTO data_t2 VALUES(8, 8, 8, 0);
|
||||
INSERT INTO data_t2 VALUES(9, 9, 9, 0);
|
||||
}
|
||||
|
||||
dbRbu close
|
||||
}
|
||||
|
||||
foreach {tn cmd} {
|
||||
1 run_rbu
|
||||
2 step_rbu
|
||||
} {
|
||||
reset_db
|
||||
build_db db
|
||||
build_rbu testrbu.db
|
||||
|
||||
do_test 1.$tn.1 {
|
||||
$cmd test.db testrbu.db
|
||||
} {SQLITE_DONE}
|
||||
do_execsql_test 1.$tn.1 {
|
||||
SELECT * FROM t1;
|
||||
} {
|
||||
1 1 1 2 2 2 3 3 3 4 4 4
|
||||
5 5 5 6 6 6 7 7 7 8 8 8
|
||||
9 9 9
|
||||
}
|
||||
do_execsql_test 1.$tn.2 {
|
||||
SELECT * FROM t2;
|
||||
} {
|
||||
1 1 1 2 2 2 3 3 3 4 4 4
|
||||
5 5 5 6 6 6 7 7 7 8 8 8
|
||||
9 9 9
|
||||
}
|
||||
}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,129 @@
|
||||
# 2014 August 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
# TESTRUNNER: slow
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbutemplimit
|
||||
|
||||
db close
|
||||
|
||||
proc setup_databases {} {
|
||||
forcedelete test.db2
|
||||
forcedelete test.db
|
||||
sqlite3 db test.db
|
||||
execsql {
|
||||
-- Create target database schema.
|
||||
--
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b BLOB(100), c BLOB(100));
|
||||
CREATE TABLE t2(a INTEGER PRIMARY KEY, b BLOB(100), c BLOB(100));
|
||||
CREATE INDEX i1b ON t1(b);
|
||||
CREATE INDEX i1c ON t1(c);
|
||||
CREATE INDEX i2b ON t2(b);
|
||||
CREATE INDEX i2c ON t2(c);
|
||||
|
||||
-- Create a large RBU database.
|
||||
--
|
||||
ATTACH 'test.db2' AS rbu;
|
||||
CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
|
||||
WITH s(i) AS (
|
||||
VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<10000
|
||||
)
|
||||
INSERT INTO data_t1 SELECT i, randomblob(100), randomblob(100), 0 FROM s;
|
||||
CREATE TABLE rbu.data_t2(a, b, c, rbu_control);
|
||||
WITH s(i) AS (
|
||||
VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<15000
|
||||
)
|
||||
INSERT INTO data_t2 SELECT i, randomblob(100), randomblob(100), 0 FROM s;
|
||||
}
|
||||
db close
|
||||
}
|
||||
|
||||
proc run_rbu_cachesize {target rbu cachesize temp_limit} {
|
||||
sqlite3rbu rbu $target $rbu
|
||||
rbu temp_size_limit $temp_limit
|
||||
sqlite3_exec_nr [rbu db 1] "PRAGMA cache_size = $cachesize"
|
||||
while 1 {
|
||||
set rc [rbu step]
|
||||
set ::A([rbu temp_size]) 1
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
}
|
||||
list [catch {rbu close} msg] $msg
|
||||
}
|
||||
|
||||
proc step_rbu_cachesize {target rbu stepsize cachesize temp_limit} {
|
||||
set res ""
|
||||
while 1 {
|
||||
sqlite3rbu rbu $target $rbu
|
||||
rbu temp_size_limit $temp_limit
|
||||
if { [rbu temp_size_limit -1]!=$temp_limit } { error "round trip problem!" }
|
||||
sqlite3_exec_nr [rbu db 1] "PRAGMA cache_size = $cachesize"
|
||||
for {set i 0} {$i < $stepsize} {incr i} {
|
||||
set rc [rbu step]
|
||||
set ::A([rbu temp_size]) 1
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
}
|
||||
set res [list [catch {rbu close} msg] $msg]
|
||||
if {$res != "0 SQLITE_OK"} break
|
||||
}
|
||||
set res
|
||||
}
|
||||
|
||||
do_test 1.1.0 { setup_databases } {}
|
||||
|
||||
do_test 1.1.1 {
|
||||
unset -nocomplain ::A
|
||||
run_rbu_cachesize test.db test.db2 10 0
|
||||
} {0 SQLITE_DONE}
|
||||
|
||||
do_test 1.1.2 { llength [array names ::A] } 3
|
||||
|
||||
do_test 1.1.3 {
|
||||
foreach {a0 a1 a2} [lsort -integer [array names ::A]] {}
|
||||
list [expr $a0==0] \
|
||||
[expr $a1>1048576] [expr $a1<1200000] \
|
||||
[expr $a2>1500000] [expr $a2<1700000]
|
||||
} {1 1 1 1 1}
|
||||
|
||||
do_test 1.2.1 {
|
||||
setup_databases
|
||||
run_rbu_cachesize test.db test.db2 10 1000000
|
||||
} {1 SQLITE_FULL}
|
||||
do_test 1.2.2 { info commands rbu } {}
|
||||
|
||||
do_test 1.3.1 {
|
||||
setup_databases
|
||||
run_rbu_cachesize test.db test.db2 10 1300000
|
||||
} {1 SQLITE_FULL}
|
||||
do_test 1.3.2 { info commands rbu } {}
|
||||
|
||||
do_test 1.4.1 {
|
||||
setup_databases
|
||||
run_rbu_cachesize test.db test.db2 10 1800000
|
||||
} {0 SQLITE_DONE}
|
||||
do_test 1.4.2 { info commands rbu } {}
|
||||
|
||||
do_test 1.5.1 {
|
||||
setup_databases
|
||||
unset -nocomplain ::A
|
||||
step_rbu_cachesize test.db test.db2 1000 10 2400000
|
||||
} {0 SQLITE_DONE}
|
||||
do_test 1.5.2 { info commands rbu } {}
|
||||
|
||||
do_test 1.6.1 {
|
||||
setup_databases
|
||||
unset -nocomplain ::A
|
||||
step_rbu_cachesize test.db test.db2 1000 10 1400000
|
||||
} {1 SQLITE_FULL}
|
||||
do_test 1.6.2 { info commands rbu } {}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,400 @@
|
||||
# 2016 April 15
|
||||
#
|
||||
# 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 contains tests for the RBU module. More specifically, it
|
||||
# contains tests to ensure that the sqlite3rbu_vacuum() API works as
|
||||
# expected.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set ::testprefix rbuvacuum
|
||||
|
||||
foreach step {0 1} {
|
||||
|
||||
set ::testprefix rbuvacuum-step=$step
|
||||
reset_db
|
||||
|
||||
# Simplest possible vacuum.
|
||||
do_execsql_test 1.0 {
|
||||
PRAGMA page_size = 1024;
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
INSERT INTO t1 VALUES(7, 8, 9);
|
||||
PRAGMA integrity_check;
|
||||
} {ok}
|
||||
do_rbu_vacuum_test 1.1 $step
|
||||
|
||||
# A vacuum that actually reclaims space.
|
||||
do_execsql_test 1.2.1 {
|
||||
INSERT INTO t1 VALUES(8, randomblob(900), randomblob(900));
|
||||
INSERT INTO t1 VALUES(9, randomblob(900), randomblob(900));
|
||||
INSERT INTO t1 VALUES(10, randomblob(900), randomblob(900));
|
||||
INSERT INTO t1 VALUES(11, randomblob(900), randomblob(900));
|
||||
INSERT INTO t1 VALUES(12, randomblob(900), randomblob(900));
|
||||
PRAGMA page_count;
|
||||
} {12}
|
||||
do_execsql_test 1.2.2 {
|
||||
DELETE FROM t1 WHERE rowid BETWEEN 8 AND 11;
|
||||
PRAGMA page_count;
|
||||
} {12}
|
||||
do_rbu_vacuum_test 1.2.3 $step
|
||||
do_execsql_test 1.2.4 {
|
||||
PRAGMA page_count;
|
||||
} {3}
|
||||
|
||||
# Add an index to the table.
|
||||
do_execsql_test 1.3.1 {
|
||||
CREATE INDEX t1b ON t1(b);
|
||||
INSERT INTO t1 VALUES(13, randomblob(900), randomblob(900));
|
||||
INSERT INTO t1 VALUES(14, randomblob(900), randomblob(900));
|
||||
INSERT INTO t1 VALUES(15, randomblob(900), randomblob(900));
|
||||
INSERT INTO t1 VALUES(16, randomblob(900), randomblob(900));
|
||||
PRAGMA page_count;
|
||||
} {18}
|
||||
do_execsql_test 1.3.2 {
|
||||
DELETE FROM t1 WHERE rowid BETWEEN 12 AND 15;
|
||||
PRAGMA page_count;
|
||||
} {18}
|
||||
do_rbu_vacuum_test 1.3.3 $step
|
||||
do_execsql_test 1.3.4 {
|
||||
PRAGMA page_count;
|
||||
} {5}
|
||||
|
||||
# WITHOUT ROWID table.
|
||||
do_execsql_test 1.4.1 {
|
||||
CREATE TABLE t2(a, b, c, PRIMARY KEY(a, b)) WITHOUT ROWID;
|
||||
|
||||
INSERT INTO t2 VALUES(randomblob(900), 1, randomblob(900));
|
||||
INSERT INTO t2 VALUES(randomblob(900), 2, randomblob(900));
|
||||
INSERT INTO t2 VALUES(randomblob(900), 3, randomblob(900));
|
||||
INSERT INTO t2 VALUES(randomblob(900), 4, randomblob(900));
|
||||
INSERT INTO t2 VALUES(randomblob(900), 6, randomblob(900));
|
||||
INSERT INTO t2 VALUES(randomblob(900), 7, randomblob(900));
|
||||
INSERT INTO t2 VALUES(randomblob(900), 8, randomblob(900));
|
||||
|
||||
DELETE FROM t2 WHERE b BETWEEN 2 AND 7;
|
||||
PRAGMA page_count;
|
||||
} {20}
|
||||
do_rbu_vacuum_test 1.4.2 $step
|
||||
do_execsql_test 1.4.3 {
|
||||
PRAGMA page_count;
|
||||
} {10}
|
||||
|
||||
# WITHOUT ROWID table with an index.
|
||||
do_execsql_test 1.4.1 {
|
||||
CREATE INDEX t2c ON t2(c);
|
||||
|
||||
INSERT INTO t2 VALUES(randomblob(900), 9, randomblob(900));
|
||||
INSERT INTO t2 VALUES(randomblob(900), 10, randomblob(900));
|
||||
INSERT INTO t2 VALUES(randomblob(900), 11, randomblob(900));
|
||||
INSERT INTO t2 VALUES(randomblob(900), 12, randomblob(900));
|
||||
INSERT INTO t2 VALUES(randomblob(900), 13, randomblob(900));
|
||||
|
||||
DELETE FROM t2 WHERE b BETWEEN 8 AND 12;
|
||||
PRAGMA page_count;
|
||||
} {35}
|
||||
do_rbu_vacuum_test 1.4.2 $step
|
||||
do_execsql_test 1.4.3 {
|
||||
PRAGMA page_count;
|
||||
} {15}
|
||||
do_execsql_test 1.4.4 {
|
||||
VACUUM;
|
||||
PRAGMA page_count;
|
||||
} {15}
|
||||
|
||||
do_execsql_test 1.5.1 {
|
||||
CREATE TABLE t3(a, b, c);
|
||||
INSERT INTO t3 VALUES('a', 'b', 'c');
|
||||
INSERT INTO t3 VALUES('d', 'e', 'f');
|
||||
INSERT INTO t3 VALUES('g', 'h', 'i');
|
||||
}
|
||||
do_rbu_vacuum_test 1.5.2 $step
|
||||
do_execsql_test 1.5.3 {
|
||||
SELECT * FROM t3
|
||||
} {a b c d e f g h i}
|
||||
do_execsql_test 1.5.4 {
|
||||
CREATE INDEX t3a ON t3(a);
|
||||
CREATE INDEX t3b ON t3(b);
|
||||
CREATE INDEX t3c ON t3(c);
|
||||
INSERT INTO t3 VALUES('j', 'k', 'l');
|
||||
DELETE FROM t3 WHERE a = 'g';
|
||||
}
|
||||
do_rbu_vacuum_test 1.5.5 $step
|
||||
do_execsql_test 1.5.6 {
|
||||
SELECT rowid, * FROM t3 ORDER BY b
|
||||
} {1 a b c 2 d e f 4 j k l}
|
||||
|
||||
do_execsql_test 1.6.1 {
|
||||
CREATE TABLE t4(a PRIMARY KEY, b, c);
|
||||
INSERT INTO t4 VALUES('a', 'b', 'c');
|
||||
INSERT INTO t4 VALUES('d', 'e', 'f');
|
||||
INSERT INTO t4 VALUES('g', 'h', 'i');
|
||||
}
|
||||
do_rbu_vacuum_test 1.6.2 $step
|
||||
do_execsql_test 1.6.3 {
|
||||
SELECT * FROM t4
|
||||
} {a b c d e f g h i}
|
||||
do_execsql_test 1.6.4 {
|
||||
CREATE INDEX t4a ON t4(a);
|
||||
CREATE INDEX t4b ON t4(b);
|
||||
CREATE INDEX t4c ON t4(c);
|
||||
|
||||
INSERT INTO t4 VALUES('j', 'k', 'l');
|
||||
DELETE FROM t4 WHERE a='g';
|
||||
}
|
||||
do_rbu_vacuum_test 1.6.5 $step
|
||||
do_execsql_test 1.6.6 {
|
||||
SELECT * FROM t4 ORDER BY b
|
||||
} {a b c d e f j k l}
|
||||
|
||||
reset_db
|
||||
do_execsql_test 1.7.0 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
|
||||
INSERT INTO t1 VALUES(NULL, 'one');
|
||||
INSERT INTO t1 VALUES(NULL, 'two');
|
||||
DELETE FROM t1 WHERE a=2;
|
||||
INSERT INTO t1 VALUES(NULL, 'three');
|
||||
INSERT INTO t1 VALUES(NULL, 'four');
|
||||
DELETE FROM t1 WHERE a=4;
|
||||
INSERT INTO t1 VALUES(NULL, 'five');
|
||||
INSERT INTO t1 VALUES(NULL, 'six');
|
||||
DELETE FROM t1 WHERE a=6;
|
||||
SELECT * FROM t1;
|
||||
} {1 one 3 three 5 five}
|
||||
do_rbu_vacuum_test 1.7.1 $step
|
||||
do_execsql_test 1.7.2 {
|
||||
INSERT INTO t1 VALUES(NULL, 'seven');
|
||||
SELECT * FROM t1;
|
||||
} {1 one 3 three 5 five 7 seven}
|
||||
|
||||
reset_db
|
||||
do_execsql_test 1.8.0 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
INSERT INTO t1 VALUES(NULL, 'one');
|
||||
INSERT INTO t1 VALUES(NULL, 'two');
|
||||
INSERT INTO t1 VALUES(NULL, 'three');
|
||||
INSERT INTO t1 VALUES(NULL, 'four');
|
||||
INSERT INTO t1 VALUES(NULL, 'five');
|
||||
INSERT INTO t1 VALUES(NULL, 'six');
|
||||
ANALYZE;
|
||||
SELECT * FROM sqlite_stat1;
|
||||
} {t1 i1 {6 1}}
|
||||
do_rbu_vacuum_test 1.8.1 $step
|
||||
do_execsql_test 1.7.2 {
|
||||
SELECT * FROM sqlite_stat1;
|
||||
} {t1 i1 {6 1}}
|
||||
|
||||
reset_db
|
||||
do_execsql_test 1.9.0 {
|
||||
PRAGMA page_size = 8192;
|
||||
PRAGMA auto_vacuum = 2;
|
||||
PRAGMA user_version = 412;
|
||||
PRAGMA application_id = 413;
|
||||
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY AUTOINCREMENT, b);
|
||||
CREATE INDEX i1 ON t1(b);
|
||||
INSERT INTO t1 VALUES(NULL, 'one');
|
||||
INSERT INTO t1 VALUES(NULL, 'two');
|
||||
INSERT INTO t1 VALUES(NULL, 'three');
|
||||
INSERT INTO t1 VALUES(NULL, 'four');
|
||||
INSERT INTO t1 VALUES(NULL, 'five');
|
||||
INSERT INTO t1 VALUES(NULL, 'six');
|
||||
|
||||
PRAGMA main.page_size;
|
||||
PRAGMA main.auto_vacuum;
|
||||
PRAGMA main.user_version;
|
||||
PRAGMA main.application_id;
|
||||
} {8192 2 412 413}
|
||||
|
||||
do_rbu_vacuum_test 1.9.1 $step
|
||||
do_execsql_test 1.9.2 {
|
||||
PRAGMA main.page_size;
|
||||
PRAGMA main.auto_vacuum;
|
||||
PRAGMA main.user_version;
|
||||
PRAGMA main.application_id;
|
||||
} {8192 2 412 413}
|
||||
|
||||
# Vacuum a database with a large sqlite_master table.
|
||||
#
|
||||
reset_db
|
||||
do_test 1.10.1 {
|
||||
for {set i 1} {$i < 50} {incr i} {
|
||||
execsql "PRAGMA page_size = 1024"
|
||||
execsql "CREATE TABLE t$i (a, b, c, PRIMARY KEY(a, b));"
|
||||
execsql "
|
||||
INSERT INTO t$i VALUES(1, 2, 3);
|
||||
INSERT INTO t$i VALUES(4, 5, 6);
|
||||
"
|
||||
}
|
||||
} {}
|
||||
do_rbu_vacuum_test 1.10.2 $step
|
||||
|
||||
# Database with empty tables.
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 1.11.1 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
|
||||
CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
|
||||
CREATE TABLE t3(a INTEGER PRIMARY KEY, b);
|
||||
CREATE TABLE t4(a INTEGER PRIMARY KEY, b);
|
||||
INSERT INTO t4 VALUES(1, 2);
|
||||
}
|
||||
do_rbu_vacuum_test 1.11.2 $step
|
||||
do_execsql_test 1.11.3 {
|
||||
SELECT * FROM t1;
|
||||
SELECT * FROM t2;
|
||||
SELECT * FROM t3;
|
||||
SELECT * FROM t4;
|
||||
} {1 2}
|
||||
reset_db
|
||||
do_execsql_test 1.12.1 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
|
||||
CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
|
||||
CREATE TABLE t3(a INTEGER PRIMARY KEY, b);
|
||||
CREATE TABLE t4(a INTEGER PRIMARY KEY, b);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
}
|
||||
do_rbu_vacuum_test 1.12.2 $step
|
||||
do_execsql_test 1.12.3 {
|
||||
SELECT * FROM t1;
|
||||
SELECT * FROM t2;
|
||||
SELECT * FROM t3;
|
||||
SELECT * FROM t4;
|
||||
} {1 2}
|
||||
}
|
||||
set ::testprefix rbuvacuum
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test some error cases:
|
||||
#
|
||||
# 2.1.* the db being vacuumed being in wal mode already.
|
||||
# 2.2.* database modified mid vacuum.
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 2.1.0 {
|
||||
CREATE TABLE t1(a, b);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
INSERT INTO t1 VALUES(3, 4);
|
||||
INSERT INTO t1 VALUES(5, 6);
|
||||
INSERT INTO t1 VALUES(7, 8);
|
||||
PRAGMA journal_mode = wal;
|
||||
INSERT INTO t1 VALUES(9, 10);
|
||||
} wal
|
||||
do_test 2.1.1 {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
rbu step
|
||||
} {SQLITE_ERROR}
|
||||
do_test 2.1.2 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_ERROR - cannot vacuum wal mode database}}
|
||||
|
||||
do_test 2.1.3 {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
rbu step
|
||||
} {SQLITE_ERROR}
|
||||
do_test 2.1.4 {
|
||||
list [catch { rbu close_no_error } msg] $msg
|
||||
} {1 SQLITE_ERROR}
|
||||
|
||||
reset_db
|
||||
do_execsql_test 2.2.0 {
|
||||
CREATE TABLE tx(a PRIMARY KEY, b BLOB);
|
||||
INSERT INTO tx VALUES(1, randomblob(900));
|
||||
INSERT INTO tx SELECT a+1, randomblob(900) FROM tx;
|
||||
INSERT INTO tx SELECT a+2, randomblob(900) FROM tx;
|
||||
INSERT INTO tx SELECT a+4, randomblob(900) FROM tx;
|
||||
INSERT INTO tx SELECT a+8, randomblob(900) FROM tx;
|
||||
}
|
||||
db_save_and_close
|
||||
for {set i 1} 1 {incr i} {
|
||||
db_restore_and_reopen
|
||||
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
for {set step 0} {$step<$i} {incr step} { rbu step }
|
||||
rbu close
|
||||
if {[file exists test.db-wal]} break
|
||||
|
||||
execsql { INSERT INTO tx VALUES(20, 20) }
|
||||
|
||||
do_test 2.2.$i.1 {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
rbu step
|
||||
} {SQLITE_BUSY}
|
||||
do_test 2.2.$i.2 {
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_BUSY - database modified during rbu vacuum}}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that a database that uses custom collation sequences can be RBU
|
||||
# vacuumed.
|
||||
#
|
||||
reset_db
|
||||
forcedelete state.db
|
||||
proc noop {args} {}
|
||||
proc length_cmp {x y} {
|
||||
set n1 [string length $x]
|
||||
set n2 [string length $y]
|
||||
return [expr $n1 - $n2]
|
||||
}
|
||||
sqlite3_create_collation_v2 db length length_cmp noop
|
||||
|
||||
do_execsql_test 3.0 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
|
||||
INSERT INTO t1 VALUES(1, 'i');
|
||||
INSERT INTO t1 VALUES(2, 'iiii');
|
||||
INSERT INTO t1 VALUES(3, 'ii');
|
||||
INSERT INTO t1 VALUES(4, 'iii');
|
||||
SELECT a FROM t1 ORDER BY b COLLATE length;
|
||||
} {1 3 4 2}
|
||||
do_execsql_test 3.1 {
|
||||
CREATE INDEX i1 ON t1(b COLLATE length);
|
||||
}
|
||||
|
||||
do_test 3.2 {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_ERROR - no such collation sequence: length}}
|
||||
|
||||
do_test 3.3 {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
set db1 [rbu db 0]
|
||||
sqlite3_create_collation_v2 $db1 length length_cmp noop
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_ERROR - no such collation sequence: length}}
|
||||
|
||||
do_test 3.4 {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
set db1 [rbu db 1]
|
||||
sqlite3_create_collation_v2 $db1 length length_cmp noop
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 {SQLITE_ERROR - no such collation sequence: length}}
|
||||
|
||||
do_test 3.5 {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
set db1 [rbu db 0]
|
||||
set db2 [rbu db 1]
|
||||
|
||||
sqlite3_create_collation_v2 $db1 length length_cmp noop
|
||||
sqlite3_create_collation_v2 $db2 length length_cmp noop
|
||||
|
||||
while {[rbu step]=="SQLITE_OK"} {}
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {0 SQLITE_DONE}
|
||||
|
||||
catch { db close }
|
||||
finish_test
|
||||
@@ -0,0 +1,249 @@
|
||||
# 2016 June 1
|
||||
#
|
||||
# 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 contains tests for the RBU module. More specifically, it
|
||||
# contains tests to ensure that the sqlite3rbu_vacuum() API works as
|
||||
# expected.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
|
||||
foreach {step} {0 1} {
|
||||
foreach {ttt state} {
|
||||
s state.db t test.db-vacuum n {}
|
||||
} {
|
||||
set ::testprefix rbuvacuum2-$step$ttt
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that a database that contains fts3 tables can be vacuumed.
|
||||
#
|
||||
ifcapable fts3 {
|
||||
reset_db
|
||||
do_execsql_test 1.1 {
|
||||
CREATE VIRTUAL TABLE t1 USING fts3(z, y);
|
||||
INSERT INTO t1 VALUES('fix this issue', 'at some point');
|
||||
}
|
||||
|
||||
do_rbu_vacuum_test 1.2 $step $state
|
||||
|
||||
do_execsql_test 1.3 {
|
||||
SELECT * FROM t1;
|
||||
} {{fix this issue} {at some point}}
|
||||
|
||||
do_execsql_test 1.4 {
|
||||
SELECT rowid FROM t1 WHERE t1 MATCH 'fix';
|
||||
} {1}
|
||||
|
||||
do_execsql_test 1.5 {
|
||||
INSERT INTO t1 VALUES('a b c', 'd e f');
|
||||
INSERT INTO t1 VALUES('l h i', 'd e f');
|
||||
DELETE FROM t1 WHERE docid = 2;
|
||||
INSERT INTO t1 VALUES('a b c', 'x y z');
|
||||
}
|
||||
|
||||
do_rbu_vacuum_test 1.6 $step $state
|
||||
do_execsql_test 1.7 {
|
||||
INSERT INTO t1(t1) VALUES('integrity-check');
|
||||
SELECT * FROM t1;
|
||||
} {
|
||||
{fix this issue} {at some point}
|
||||
{l h i} {d e f}
|
||||
{a b c} {x y z}
|
||||
}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that a database that contains fts5 tables can be vacuumed.
|
||||
#
|
||||
ifcapable fts5 {
|
||||
reset_db
|
||||
do_execsql_test 2.1 {
|
||||
CREATE VIRTUAL TABLE t1 USING fts5(z, y);
|
||||
INSERT INTO t1 VALUES('fix this issue', 'at some point');
|
||||
}
|
||||
|
||||
do_rbu_vacuum_test 2.2 $step $state
|
||||
|
||||
do_execsql_test 2.3 {
|
||||
SELECT * FROM t1;
|
||||
} {{fix this issue} {at some point}}
|
||||
|
||||
do_execsql_test 2.4 {
|
||||
SELECT rowid FROM t1 ('fix');
|
||||
} {1}
|
||||
|
||||
do_execsql_test 2.5 {
|
||||
INSERT INTO t1 VALUES('a b c', 'd e f');
|
||||
INSERT INTO t1 VALUES('l h i', 'd e f');
|
||||
DELETE FROM t1 WHERE rowid = 2;
|
||||
INSERT INTO t1 VALUES('a b c', 'x y z');
|
||||
}
|
||||
|
||||
do_rbu_vacuum_test 2.6 $step $state
|
||||
do_execsql_test 2.7 {
|
||||
INSERT INTO t1(t1) VALUES('integrity-check');
|
||||
SELECT * FROM t1;
|
||||
} {
|
||||
{fix this issue} {at some point}
|
||||
{l h i} {d e f}
|
||||
{a b c} {x y z}
|
||||
}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that a database that contains an rtree table can be vacuumed.
|
||||
#
|
||||
ifcapable rtree {
|
||||
reset_db
|
||||
do_execsql_test 3.1 {
|
||||
CREATE VIRTUAL TABLE rt USING rtree(id, x1, x2);
|
||||
INSERT INTO rt VALUES(1, 45, 55);
|
||||
INSERT INTO rt VALUES(2, 50, 60);
|
||||
INSERT INTO rt VALUES(3, 55, 65);
|
||||
}
|
||||
|
||||
do_rbu_vacuum_test 3.2 $step $state
|
||||
|
||||
do_execsql_test 3.3 {
|
||||
SELECT * FROM rt;
|
||||
} {1 45.0 55.0 2 50.0 60.0 3 55.0 65.0}
|
||||
|
||||
do_execsql_test 3.4.1 {
|
||||
SELECT rowid FROM rt WHERE x2>51 AND x1 < 51
|
||||
} {1 2}
|
||||
do_execsql_test 3.4.2 {
|
||||
SELECT rowid FROM rt WHERE x2>59 AND x1 < 59
|
||||
} {2 3}
|
||||
|
||||
do_rbu_vacuum_test 3.5 $step $state
|
||||
|
||||
do_execsql_test 3.6.1 {
|
||||
SELECT rowid FROM rt WHERE x2>51 AND x1 < 51
|
||||
} {1 2}
|
||||
do_execsql_test 3.6.2 {
|
||||
SELECT rowid FROM rt WHERE x2>59 AND x1 < 59
|
||||
} {2 3}
|
||||
}
|
||||
|
||||
ifcapable trigger {
|
||||
reset_db
|
||||
do_execsql_test 4.1 {
|
||||
CREATE TABLE t1(a, b, c);
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
CREATE VIEW v1 AS SELECT * FROM t1;
|
||||
CREATE TRIGGER tr1 AFTER INSERT ON t1 BEGIN SELECT 1; END;
|
||||
}
|
||||
|
||||
do_execsql_test 4.2 {
|
||||
SELECT * FROM sqlite_master;
|
||||
} {
|
||||
table t1 t1 2 {CREATE TABLE t1(a, b, c)}
|
||||
view v1 v1 0 {CREATE VIEW v1 AS SELECT * FROM t1}
|
||||
trigger tr1 t1 0 {CREATE TRIGGER tr1 AFTER INSERT ON t1 BEGIN SELECT 1; END}
|
||||
}
|
||||
|
||||
do_rbu_vacuum_test 4.3 $step $state
|
||||
do_execsql_test 4.4 {
|
||||
SELECT * FROM sqlite_master;
|
||||
} {
|
||||
table t1 t1 2 {CREATE TABLE t1(a, b, c)}
|
||||
view v1 v1 0 {CREATE VIEW v1 AS SELECT * FROM t1}
|
||||
trigger tr1 t1 0 {CREATE TRIGGER tr1 AFTER INSERT ON t1 BEGIN SELECT 1; END}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that passing a NULL value as the second argument to
|
||||
# sqlite3rbu_vacuum() causes it to:
|
||||
#
|
||||
# * Use <database>-vacuum as the state db, and
|
||||
# * Set the state db permissions to the same as those on the db file.
|
||||
#
|
||||
db close
|
||||
if {$::tcl_platform(platform) eq "unix"} {
|
||||
forcedelete test.db
|
||||
|
||||
sqlite3 db test.db
|
||||
do_execsql_test 5.0 {
|
||||
CREATE TABLE t1(a, b);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
INSERT INTO t1 VALUES(3, 4);
|
||||
INSERT INTO t1 VALUES(5, 6);
|
||||
INSERT INTO t1 VALUES(7, 8);
|
||||
}
|
||||
db close
|
||||
|
||||
foreach {tn perm} {
|
||||
1 00755
|
||||
2 00666
|
||||
3 00644
|
||||
4 00444
|
||||
} {
|
||||
forcedelete test.db-vacuum
|
||||
|
||||
do_test 5.$tn.1 {
|
||||
file attributes test.db -permissions $perm
|
||||
sqlite3rbu_vacuum rbu test.db
|
||||
rbu step
|
||||
} {SQLITE_OK}
|
||||
|
||||
do_test 5.$tn.2 { file exists test.db-vacuum } 1
|
||||
# The result pattern might be 00xxx or 0oxxx depending on which
|
||||
# version of TCL is being used. So make perm2 into a regexp that
|
||||
# will match either
|
||||
regsub {^00} $perm {0.} perm2
|
||||
do_test 5.$tn.3 { file attributes test.db-vacuum -permissions} /$perm2/
|
||||
rbu close
|
||||
}
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test the outcome of some other connection running a checkpoint while
|
||||
# the incremental checkpoint is suspended.
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 6.0 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1b ON t1(b);
|
||||
CREATE INDEX i1c ON t1(c);
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
}
|
||||
forcedelete test.db2
|
||||
|
||||
do_test 6.1 {
|
||||
sqlite3rbu_vacuum rbu test.db test.db2
|
||||
while {[rbu state]!="checkpoint"} { rbu step }
|
||||
rbu close
|
||||
} {SQLITE_OK}
|
||||
|
||||
do_test 6.2 {
|
||||
execsql { SELECT 1 FROM sqlite_master LIMIT 1 }
|
||||
execsql { PRAGMA wal_checkpoint }
|
||||
execsql { SELECT 1 FROM sqlite_master LIMIT 1 }
|
||||
} {1}
|
||||
|
||||
do_test 6.3 {
|
||||
sqlite3rbu_vacuum rbu test.db test.db2
|
||||
while {[rbu step]!="SQLITE_DONE"} { rbu step }
|
||||
rbu close
|
||||
execsql { PRAGMA integrity_check }
|
||||
} {ok}
|
||||
|
||||
do_test 6.4 {
|
||||
sqlite3rbu_vacuum rbu test.db test.db-vactmp
|
||||
list [catch { rbu close } msg] $msg
|
||||
} {1 SQLITE_MISUSE}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,64 @@
|
||||
# 2019 Jan 3
|
||||
#
|
||||
# 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 contains tests for the RBU module. More specifically, it
|
||||
# contains tests to ensure that the sqlite3rbu_vacuum() API works as
|
||||
# expected.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set testprefix rbuvacuum3
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1b ON t1(b);
|
||||
CREATE INDEX i1c ON t1(c);
|
||||
|
||||
WITH s(i) AS (
|
||||
VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<100
|
||||
)
|
||||
INSERT INTO t1 SELECT i, randomblob(100), randomblob(100) FROM s;
|
||||
}
|
||||
|
||||
forcedelete state.db
|
||||
do_test 1.1 {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
while {1} {
|
||||
set rc [rbu step]
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
rbu savestate
|
||||
}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 1.2 {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
while {1} {
|
||||
set rc [rbu step]
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
rbu savestate
|
||||
}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
do_test 1.3 {
|
||||
while {1} {
|
||||
sqlite3rbu_vacuum rbu test.db state.db
|
||||
set rc [rbu step]
|
||||
if {$rc!="SQLITE_OK"} break
|
||||
rbu savestate
|
||||
rbu close
|
||||
}
|
||||
rbu close
|
||||
} {SQLITE_DONE}
|
||||
|
||||
finish_test
|
||||
@@ -0,0 +1,118 @@
|
||||
# 2019 Jan 3
|
||||
#
|
||||
# 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 contains tests for the RBU module. More specifically, it
|
||||
# contains tests to ensure that the sqlite3rbu_vacuum() API works as
|
||||
# expected.
|
||||
#
|
||||
|
||||
source [file join [file dirname [info script]] rbu_common.tcl]
|
||||
if_no_rbu_support { finish_test ; return }
|
||||
set testprefix rbuvacuum4
|
||||
|
||||
set step 1
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b, c) WITHOUT ROWID;
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
INSERT INTO t1 VALUES(7, 8, 9);
|
||||
}
|
||||
do_rbu_vacuum_test 1.1 1
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
reset_db
|
||||
|
||||
do_execsql_test 2.0 {
|
||||
CREATE TABLE t1(a, b, c, PRIMARY KEY(a, b, c)) WITHOUT ROWID;
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
INSERT INTO t1 VALUES(7, 8, 9);
|
||||
}
|
||||
do_rbu_vacuum_test 2.1 1
|
||||
do_execsql_test 2.2 {
|
||||
SELECT * FROM t1;
|
||||
} {1 2 3 4 5 6 7 8 9}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
reset_db
|
||||
|
||||
do_execsql_test 3.0 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
CREATE INDEX i1 oN t1(b, c);
|
||||
INSERT INTO t1 VALUES(1, 2, 3);
|
||||
INSERT INTO t1 VALUES(4, 5, 6);
|
||||
INSERT INTO t1 VALUES(7, 8, 9);
|
||||
|
||||
CREATE TABLE t2(a, b, c INTEGER, PRIMARY KEY(c));
|
||||
CREATE INDEX i2 oN t2(b, a);
|
||||
INSERT INTO t2 VALUES('a', 'b', -1);
|
||||
INSERT INTO t2 VALUES('c', 'd', -2);
|
||||
INSERT INTO t2 VALUES('e', 'f', -3);
|
||||
}
|
||||
|
||||
do_rbu_vacuum_test 3.1 1
|
||||
|
||||
do_execsql_test 3.2 {
|
||||
SELECT * FROM t1;
|
||||
SELECT * FROM t2;
|
||||
} {1 2 3 4 5 6 7 8 9 e f -3 c d -2 a b -1}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
reset_db
|
||||
do_execsql_test 4.0 {
|
||||
CREATE TABLE x1(a, b, c, d, PRIMARY KEY(c, b)) WITHOUT ROWID;
|
||||
INSERT INTO x1 VALUES(1, 1, 1, 1);
|
||||
INSERT INTO x1 VALUES(1, 1, 2, 1);
|
||||
INSERT INTO x1 VALUES(1, 2, 2, 1);
|
||||
|
||||
INSERT INTO x1 VALUES(NULL, 2, 3, NULL);
|
||||
INSERT INTO x1 VALUES(NULL, 2, 4, NULL);
|
||||
INSERT INTO x1 VALUES(NULL, 2, 5, NULL);
|
||||
|
||||
CREATE INDEX x1ad ON x1(d, a);
|
||||
CREATE INDEX x1null ON x1(d, a) WHERE d>15;
|
||||
}
|
||||
|
||||
do_rbu_vacuum_test 4.1.1 1
|
||||
|
||||
do_execsql_test 4.2 {
|
||||
SELECT count(*) fROM x1
|
||||
} 6
|
||||
|
||||
db cache flush
|
||||
do_rbu_vacuum_test 4.1.2 0
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
reset_db
|
||||
do_execsql_test 5.0 {
|
||||
CREATE TABLE "a b c"(a, "b b" PRIMARY KEY, "c c");
|
||||
CREATE INDEX abc1 ON "a b c"(a, "c c");
|
||||
|
||||
INSERT INTO "a b c" VALUES(NULL, 'a', NULL);
|
||||
INSERT INTO "a b c" VALUES(NULL, 'b', NULL);
|
||||
INSERT INTO "a b c" VALUES(NULL, 'c', NULL);
|
||||
|
||||
INSERT INTO "a b c" VALUES(1, 2, 3);
|
||||
INSERT INTO "a b c" VALUES(3, 9, 1);
|
||||
INSERT INTO "a b c" VALUES('aaa', 'bbb', 'ccc');
|
||||
|
||||
CREATE INDEX abc2 ON "a b c"("c c" DESC, a);
|
||||
|
||||
CREATE TABLE x(a);
|
||||
INSERT INTO x VALUES('a'), ('b'), ('d');
|
||||
CREATE UNIQUE INDEX y ON x(a);
|
||||
}
|
||||
|
||||
do_rbu_vacuum_test 5.1 1
|
||||
|
||||
finish_test
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,633 @@
|
||||
/*
|
||||
** 2014 August 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 contains the public interface for the RBU extension.
|
||||
*/
|
||||
|
||||
/*
|
||||
** SUMMARY
|
||||
**
|
||||
** Writing a transaction containing a large number of operations on
|
||||
** b-tree indexes that are collectively larger than the available cache
|
||||
** memory can be very inefficient.
|
||||
**
|
||||
** The problem is that in order to update a b-tree, the leaf page (at least)
|
||||
** containing the entry being inserted or deleted must be modified. If the
|
||||
** working set of leaves is larger than the available cache memory, then a
|
||||
** single leaf that is modified more than once as part of the transaction
|
||||
** may be loaded from or written to the persistent media multiple times.
|
||||
** Additionally, because the index updates are likely to be applied in
|
||||
** random order, access to pages within the database is also likely to be in
|
||||
** random order, which is itself quite inefficient.
|
||||
**
|
||||
** One way to improve the situation is to sort the operations on each index
|
||||
** by index key before applying them to the b-tree. This leads to an IO
|
||||
** pattern that resembles a single linear scan through the index b-tree,
|
||||
** and all but guarantees each modified leaf page is loaded and stored
|
||||
** exactly once. SQLite uses this trick to improve the performance of
|
||||
** CREATE INDEX commands. This extension allows it to be used to improve
|
||||
** the performance of large transactions on existing databases.
|
||||
**
|
||||
** Additionally, this extension allows the work involved in writing the
|
||||
** large transaction to be broken down into sub-transactions performed
|
||||
** sequentially by separate processes. This is useful if the system cannot
|
||||
** guarantee that a single update process will run for long enough to apply
|
||||
** the entire update, for example because the update is being applied on a
|
||||
** mobile device that is frequently rebooted. Even after the writer process
|
||||
** has committed one or more sub-transactions, other database clients continue
|
||||
** to read from the original database snapshot. In other words, partially
|
||||
** applied transactions are not visible to other clients.
|
||||
**
|
||||
** "RBU" stands for "Resumable Bulk Update". As in a large database update
|
||||
** transmitted via a wireless network to a mobile device. A transaction
|
||||
** applied using this extension is hence referred to as an "RBU update".
|
||||
**
|
||||
**
|
||||
** LIMITATIONS
|
||||
**
|
||||
** An "RBU update" transaction is subject to the following limitations:
|
||||
**
|
||||
** * The transaction must consist of INSERT, UPDATE and DELETE operations
|
||||
** only.
|
||||
**
|
||||
** * INSERT statements may not use any default values.
|
||||
**
|
||||
** * UPDATE and DELETE statements must identify their target rows by
|
||||
** non-NULL PRIMARY KEY values. Rows with NULL values stored in PRIMARY
|
||||
** KEY fields may not be updated or deleted. If the table being written
|
||||
** has no PRIMARY KEY, affected rows must be identified by rowid.
|
||||
**
|
||||
** * UPDATE statements may not modify PRIMARY KEY columns.
|
||||
**
|
||||
** * No triggers will be fired.
|
||||
**
|
||||
** * No foreign key violations are detected or reported.
|
||||
**
|
||||
** * CHECK constraints are not enforced.
|
||||
**
|
||||
** * No constraint handling mode except for "OR ROLLBACK" is supported.
|
||||
**
|
||||
**
|
||||
** PREPARATION
|
||||
**
|
||||
** An "RBU update" is stored as a separate SQLite database. A database
|
||||
** containing an RBU update is an "RBU database". For each table in the
|
||||
** target database to be updated, the RBU database should contain a table
|
||||
** named "data_<target name>" containing the same set of columns as the
|
||||
** target table, and one more - "rbu_control". The data_% table should
|
||||
** have no PRIMARY KEY or UNIQUE constraints, but each column should have
|
||||
** the same type as the corresponding column in the target database.
|
||||
** The "rbu_control" column should have no type at all. For example, if
|
||||
** the target database contains:
|
||||
**
|
||||
** CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c UNIQUE);
|
||||
**
|
||||
** Then the RBU database should contain:
|
||||
**
|
||||
** CREATE TABLE data_t1(a INTEGER, b TEXT, c, rbu_control);
|
||||
**
|
||||
** The order of the columns in the data_% table does not matter.
|
||||
**
|
||||
** Instead of a regular table, the RBU database may also contain virtual
|
||||
** tables or views named using the data_<target> naming scheme.
|
||||
**
|
||||
** Instead of the plain data_<target> naming scheme, RBU database tables
|
||||
** may also be named data<integer>_<target>, where <integer> is any sequence
|
||||
** of zero or more numeric characters (0-9). This can be significant because
|
||||
** tables within the RBU database are always processed in order sorted by
|
||||
** name. By judicious selection of the <integer> portion of the names
|
||||
** of the RBU tables the user can therefore control the order in which they
|
||||
** are processed. This can be useful, for example, to ensure that "external
|
||||
** content" FTS4 tables are updated before their underlying content tables.
|
||||
**
|
||||
** If the target database table is a virtual table or a table that has no
|
||||
** PRIMARY KEY declaration, the data_% table must also contain a column
|
||||
** named "rbu_rowid". This column is mapped to the table's implicit primary
|
||||
** key column - "rowid". Virtual tables for which the "rowid" column does
|
||||
** not function like a primary key value cannot be updated using RBU. For
|
||||
** example, if the target db contains either of the following:
|
||||
**
|
||||
** CREATE VIRTUAL TABLE x1 USING fts3(a, b);
|
||||
** CREATE TABLE x1(a, b)
|
||||
**
|
||||
** then the RBU database should contain:
|
||||
**
|
||||
** CREATE TABLE data_x1(a, b, rbu_rowid, rbu_control);
|
||||
**
|
||||
** All non-hidden columns (i.e. all columns matched by "SELECT *") of the
|
||||
** target table must be present in the input table. For virtual tables,
|
||||
** hidden columns are optional - they are updated by RBU if present in
|
||||
** the input table, or not otherwise. For example, to write to an fts4
|
||||
** table with a hidden languageid column such as:
|
||||
**
|
||||
** CREATE VIRTUAL TABLE ft1 USING fts4(a, b, languageid='langid');
|
||||
**
|
||||
** Either of the following input table schemas may be used:
|
||||
**
|
||||
** CREATE TABLE data_ft1(a, b, langid, rbu_rowid, rbu_control);
|
||||
** CREATE TABLE data_ft1(a, b, rbu_rowid, rbu_control);
|
||||
**
|
||||
** For each row to INSERT into the target database as part of the RBU
|
||||
** update, the corresponding data_% table should contain a single record
|
||||
** with the "rbu_control" column set to contain integer value 0. The
|
||||
** other columns should be set to the values that make up the new record
|
||||
** to insert.
|
||||
**
|
||||
** If the target database table has an INTEGER PRIMARY KEY, it is not
|
||||
** possible to insert a NULL value into the IPK column. Attempting to
|
||||
** do so results in an SQLITE_MISMATCH error.
|
||||
**
|
||||
** For each row to DELETE from the target database as part of the RBU
|
||||
** update, the corresponding data_% table should contain a single record
|
||||
** with the "rbu_control" column set to contain integer value 1. The
|
||||
** real primary key values of the row to delete should be stored in the
|
||||
** corresponding columns of the data_% table. The values stored in the
|
||||
** other columns are not used.
|
||||
**
|
||||
** For each row to UPDATE from the target database as part of the RBU
|
||||
** update, the corresponding data_% table should contain a single record
|
||||
** with the "rbu_control" column set to contain a value of type text.
|
||||
** The real primary key values identifying the row to update should be
|
||||
** stored in the corresponding columns of the data_% table row, as should
|
||||
** the new values of all columns being update. The text value in the
|
||||
** "rbu_control" column must contain the same number of characters as
|
||||
** there are columns in the target database table, and must consist entirely
|
||||
** of 'x' and '.' characters (or in some special cases 'd' - see below). For
|
||||
** each column that is being updated, the corresponding character is set to
|
||||
** 'x'. For those that remain as they are, the corresponding character of the
|
||||
** rbu_control value should be set to '.'. For example, given the tables
|
||||
** above, the update statement:
|
||||
**
|
||||
** UPDATE t1 SET c = 'usa' WHERE a = 4;
|
||||
**
|
||||
** is represented by the data_t1 row created by:
|
||||
**
|
||||
** INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..x');
|
||||
**
|
||||
** Instead of an 'x' character, characters of the rbu_control value specified
|
||||
** for UPDATEs may also be set to 'd'. In this case, instead of updating the
|
||||
** target table with the value stored in the corresponding data_% column, the
|
||||
** user-defined SQL function "rbu_delta()" is invoked and the result stored in
|
||||
** the target table column. rbu_delta() is invoked with two arguments - the
|
||||
** original value currently stored in the target table column and the
|
||||
** value specified in the data_xxx table.
|
||||
**
|
||||
** For example, this row:
|
||||
**
|
||||
** INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..d');
|
||||
**
|
||||
** is similar to an UPDATE statement such as:
|
||||
**
|
||||
** UPDATE t1 SET c = rbu_delta(c, 'usa') WHERE a = 4;
|
||||
**
|
||||
** Finally, if an 'f' character appears in place of a 'd' or 's' in an
|
||||
** ota_control string, the contents of the data_xxx table column is assumed
|
||||
** to be a "fossil delta" - a patch to be applied to a blob value in the
|
||||
** format used by the fossil source-code management system. In this case
|
||||
** the existing value within the target database table must be of type BLOB.
|
||||
** It is replaced by the result of applying the specified fossil delta to
|
||||
** itself.
|
||||
**
|
||||
** If the target database table is a virtual table or a table with no PRIMARY
|
||||
** KEY, the rbu_control value should not include a character corresponding
|
||||
** to the rbu_rowid value. For example, this:
|
||||
**
|
||||
** INSERT INTO data_ft1(a, b, rbu_rowid, rbu_control)
|
||||
** VALUES(NULL, 'usa', 12, '.x');
|
||||
**
|
||||
** causes a result similar to:
|
||||
**
|
||||
** UPDATE ft1 SET b = 'usa' WHERE rowid = 12;
|
||||
**
|
||||
** The data_xxx tables themselves should have no PRIMARY KEY declarations.
|
||||
** However, RBU is more efficient if reading the rows in from each data_xxx
|
||||
** table in "rowid" order is roughly the same as reading them sorted by
|
||||
** the PRIMARY KEY of the corresponding target database table. In other
|
||||
** words, rows should be sorted using the destination table PRIMARY KEY
|
||||
** fields before they are inserted into the data_xxx tables.
|
||||
**
|
||||
** USAGE
|
||||
**
|
||||
** The API declared below allows an application to apply an RBU update
|
||||
** stored on disk to an existing target database. Essentially, the
|
||||
** application:
|
||||
**
|
||||
** 1) Opens an RBU handle using the sqlite3rbu_open() function.
|
||||
**
|
||||
** 2) Registers any required virtual table modules with the database
|
||||
** handle returned by sqlite3rbu_db(). Also, if required, register
|
||||
** the rbu_delta() implementation.
|
||||
**
|
||||
** 3) Calls the sqlite3rbu_step() function one or more times on
|
||||
** the new handle. Each call to sqlite3rbu_step() performs a single
|
||||
** b-tree operation, so thousands of calls may be required to apply
|
||||
** a complete update.
|
||||
**
|
||||
** 4) Calls sqlite3rbu_close() to close the RBU update handle. If
|
||||
** sqlite3rbu_step() has been called enough times to completely
|
||||
** apply the update to the target database, then the RBU database
|
||||
** is marked as fully applied. Otherwise, the state of the RBU
|
||||
** update application is saved in the RBU database for later
|
||||
** resumption.
|
||||
**
|
||||
** See comments below for more detail on APIs.
|
||||
**
|
||||
** If an update is only partially applied to the target database by the
|
||||
** time sqlite3rbu_close() is called, various state information is saved
|
||||
** within the RBU database. This allows subsequent processes to automatically
|
||||
** resume the RBU update from where it left off.
|
||||
**
|
||||
** To remove all RBU extension state information, returning an RBU database
|
||||
** to its original contents, it is sufficient to drop all tables that begin
|
||||
** with the prefix "rbu_"
|
||||
**
|
||||
** DATABASE LOCKING
|
||||
**
|
||||
** An RBU update may not be applied to a database in WAL mode. Attempting
|
||||
** to do so is an error (SQLITE_ERROR).
|
||||
**
|
||||
** While an RBU handle is open, a SHARED lock may be held on the target
|
||||
** database file. This means it is possible for other clients to read the
|
||||
** database, but not to write it.
|
||||
**
|
||||
** If an RBU update is started and then suspended before it is completed,
|
||||
** then an external client writes to the database, then attempting to resume
|
||||
** the suspended RBU update is also an error (SQLITE_BUSY).
|
||||
*/
|
||||
|
||||
#ifndef _SQLITE3RBU_H
|
||||
#define _SQLITE3RBU_H
|
||||
|
||||
#include "sqlite3.h" /* Required for error code definitions */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct sqlite3rbu sqlite3rbu;
|
||||
|
||||
/*
|
||||
** Open an RBU handle.
|
||||
**
|
||||
** Argument zTarget is the path to the target database. Argument zRbu is
|
||||
** the path to the RBU database. Each call to this function must be matched
|
||||
** by a call to sqlite3rbu_close(). When opening the databases, RBU passes
|
||||
** the SQLITE_CONFIG_URI flag to sqlite3_open_v2(). So if either zTarget
|
||||
** or zRbu begin with "file:", it will be interpreted as an SQLite
|
||||
** database URI, not a regular file name.
|
||||
**
|
||||
** If the zState argument is passed a NULL value, the RBU extension stores
|
||||
** the current state of the update (how many rows have been updated, which
|
||||
** indexes are yet to be updated etc.) within the RBU database itself. This
|
||||
** can be convenient, as it means that the RBU application does not need to
|
||||
** organize removing a separate state file after the update is concluded.
|
||||
** Or, if zState is non-NULL, it must be a path to a database file in which
|
||||
** the RBU extension can store the state of the update.
|
||||
**
|
||||
** When resuming an RBU update, the zState argument must be passed the same
|
||||
** value as when the RBU update was started.
|
||||
**
|
||||
** Once the RBU update is finished, the RBU extension does not
|
||||
** automatically remove any zState database file, even if it created it.
|
||||
**
|
||||
** By default, RBU uses the default VFS to access the files on disk. To
|
||||
** use a VFS other than the default, an SQLite "file:" URI containing a
|
||||
** "vfs=..." option may be passed as the zTarget option.
|
||||
**
|
||||
** IMPORTANT NOTE FOR ZIPVFS USERS: The RBU extension works with all of
|
||||
** SQLite's built-in VFSs, including the multiplexor VFS. However it does
|
||||
** not work out of the box with zipvfs. Refer to the comment describing
|
||||
** the zipvfs_create_vfs() API below for details on using RBU with zipvfs.
|
||||
*/
|
||||
SQLITE_API sqlite3rbu *sqlite3rbu_open(
|
||||
const char *zTarget,
|
||||
const char *zRbu,
|
||||
const char *zState
|
||||
);
|
||||
|
||||
/*
|
||||
** Open an RBU handle to perform an RBU vacuum on database file zTarget.
|
||||
** An RBU vacuum is similar to SQLite's built-in VACUUM command, except
|
||||
** that it can be suspended and resumed like an RBU update.
|
||||
**
|
||||
** The second argument to this function identifies a database in which
|
||||
** to store the state of the RBU vacuum operation if it is suspended. The
|
||||
** first time sqlite3rbu_vacuum() is called, to start an RBU vacuum
|
||||
** operation, the state database should either not exist or be empty
|
||||
** (contain no tables). If an RBU vacuum is suspended by calling
|
||||
** sqlite3rbu_close() on the RBU handle before sqlite3rbu_step() has
|
||||
** returned SQLITE_DONE, the vacuum state is stored in the state database.
|
||||
** The vacuum can be resumed by calling this function to open a new RBU
|
||||
** handle specifying the same target and state databases.
|
||||
**
|
||||
** If the second argument passed to this function is NULL, then the
|
||||
** name of the state database is "<database>-vacuum", where <database>
|
||||
** is the name of the target database file. In this case, on UNIX, if the
|
||||
** state database is not already present in the file-system, it is created
|
||||
** with the same permissions as the target db is made.
|
||||
**
|
||||
** With an RBU vacuum, it is an SQLITE_MISUSE error if the name of the
|
||||
** state database ends with "-vactmp". This name is reserved for internal
|
||||
** use.
|
||||
**
|
||||
** This function does not delete the state database after an RBU vacuum
|
||||
** is completed, even if it created it. However, if the call to
|
||||
** sqlite3rbu_close() returns any value other than SQLITE_OK, the contents
|
||||
** of the state tables within the state database are zeroed. This way,
|
||||
** the next call to sqlite3rbu_vacuum() opens a handle that starts a
|
||||
** new RBU vacuum operation.
|
||||
**
|
||||
** As with sqlite3rbu_open(), Zipvfs users should refer to the comment
|
||||
** describing the sqlite3rbu_create_vfs() API function below for
|
||||
** a description of the complications associated with using RBU with
|
||||
** zipvfs databases.
|
||||
*/
|
||||
SQLITE_API sqlite3rbu *sqlite3rbu_vacuum(
|
||||
const char *zTarget,
|
||||
const char *zState
|
||||
);
|
||||
|
||||
/*
|
||||
** Configure a limit for the amount of temp space that may be used by
|
||||
** the RBU handle passed as the first argument. The new limit is specified
|
||||
** in bytes by the second parameter. If it is positive, the limit is updated.
|
||||
** If the second parameter to this function is passed zero, then the limit
|
||||
** is removed entirely. If the second parameter is negative, the limit is
|
||||
** not modified (this is useful for querying the current limit).
|
||||
**
|
||||
** In all cases the returned value is the current limit in bytes (zero
|
||||
** indicates unlimited).
|
||||
**
|
||||
** If the temp space limit is exceeded during operation, an SQLITE_FULL
|
||||
** error is returned.
|
||||
*/
|
||||
SQLITE_API sqlite3_int64 sqlite3rbu_temp_size_limit(sqlite3rbu*, sqlite3_int64);
|
||||
|
||||
/*
|
||||
** Return the current amount of temp file space, in bytes, currently used by
|
||||
** the RBU handle passed as the only argument.
|
||||
*/
|
||||
SQLITE_API sqlite3_int64 sqlite3rbu_temp_size(sqlite3rbu*);
|
||||
|
||||
/*
|
||||
** Internally, each RBU connection uses a separate SQLite database
|
||||
** connection to access the target and rbu update databases. This
|
||||
** API allows the application direct access to these database handles.
|
||||
**
|
||||
** The first argument passed to this function must be a valid, open, RBU
|
||||
** handle. The second argument should be passed zero to access the target
|
||||
** database handle, or non-zero to access the rbu update database handle.
|
||||
** Accessing the underlying database handles may be useful in the
|
||||
** following scenarios:
|
||||
**
|
||||
** * If any target tables are virtual tables, it may be necessary to
|
||||
** call sqlite3_create_module() on the target database handle to
|
||||
** register the required virtual table implementations.
|
||||
**
|
||||
** * If the data_xxx tables in the RBU source database are virtual
|
||||
** tables, the application may need to call sqlite3_create_module() on
|
||||
** the rbu update db handle to any required virtual table
|
||||
** implementations.
|
||||
**
|
||||
** * If the application uses the "rbu_delta()" feature described above,
|
||||
** it must use sqlite3_create_function() or similar to register the
|
||||
** rbu_delta() implementation with the target database handle.
|
||||
**
|
||||
** If an error has occurred, either while opening or stepping the RBU object,
|
||||
** this function may return NULL. The error code and message may be collected
|
||||
** when sqlite3rbu_close() is called.
|
||||
**
|
||||
** Database handles returned by this function remain valid until the next
|
||||
** call to any sqlite3rbu_xxx() function other than sqlite3rbu_db().
|
||||
*/
|
||||
SQLITE_API sqlite3 *sqlite3rbu_db(sqlite3rbu*, int bRbu);
|
||||
|
||||
/*
|
||||
** Do some work towards applying the RBU update to the target db.
|
||||
**
|
||||
** Return SQLITE_DONE if the update has been completely applied, or
|
||||
** SQLITE_OK if no error occurs but there remains work to do to apply
|
||||
** the RBU update. If an error does occur, some other error code is
|
||||
** returned.
|
||||
**
|
||||
** Once a call to sqlite3rbu_step() has returned a value other than
|
||||
** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops
|
||||
** that immediately return the same value.
|
||||
*/
|
||||
SQLITE_API int sqlite3rbu_step(sqlite3rbu *pRbu);
|
||||
|
||||
/*
|
||||
** Force RBU to save its state to disk.
|
||||
**
|
||||
** If a power failure or application crash occurs during an update, following
|
||||
** system recovery RBU may resume the update from the point at which the state
|
||||
** was last saved. In other words, from the most recent successful call to
|
||||
** sqlite3rbu_close() or this function.
|
||||
**
|
||||
** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
|
||||
*/
|
||||
SQLITE_API int sqlite3rbu_savestate(sqlite3rbu *pRbu);
|
||||
|
||||
/*
|
||||
** Close an RBU handle.
|
||||
**
|
||||
** If the RBU update has been completely applied, mark the RBU database
|
||||
** as fully applied. Otherwise, assuming no error has occurred, save the
|
||||
** current state of the RBU update application to the RBU database.
|
||||
**
|
||||
** If an error has already occurred as part of an sqlite3rbu_step()
|
||||
** or sqlite3rbu_open() call, or if one occurs within this function, an
|
||||
** SQLite error code is returned. Additionally, if pzErrmsg is not NULL,
|
||||
** *pzErrmsg may be set to point to a buffer containing a utf-8 formatted
|
||||
** English language error message. It is the responsibility of the caller to
|
||||
** eventually free any such buffer using sqlite3_free().
|
||||
**
|
||||
** Otherwise, if no error occurs, this function returns SQLITE_OK if the
|
||||
** update has been partially applied, or SQLITE_DONE if it has been
|
||||
** completely applied.
|
||||
*/
|
||||
SQLITE_API int sqlite3rbu_close(sqlite3rbu *pRbu, char **pzErrmsg);
|
||||
|
||||
/*
|
||||
** Return the total number of key-value operations (inserts, deletes or
|
||||
** updates) that have been performed on the target database since the
|
||||
** current RBU update was started.
|
||||
*/
|
||||
SQLITE_API sqlite3_int64 sqlite3rbu_progress(sqlite3rbu *pRbu);
|
||||
|
||||
/*
|
||||
** Obtain permyriadage (permyriadage is to 10000 as percentage is to 100)
|
||||
** progress indications for the two stages of an RBU update. This API may
|
||||
** be useful for driving GUI progress indicators and similar.
|
||||
**
|
||||
** An RBU update is divided into two stages:
|
||||
**
|
||||
** * Stage 1, in which changes are accumulated in an oal/wal file, and
|
||||
** * Stage 2, in which the contents of the wal file are copied into the
|
||||
** main database.
|
||||
**
|
||||
** The update is visible to non-RBU clients during stage 2. During stage 1
|
||||
** non-RBU reader clients may see the original database.
|
||||
**
|
||||
** If this API is called during stage 2 of the update, output variable
|
||||
** (*pnOne) is set to 10000 to indicate that stage 1 has finished and (*pnTwo)
|
||||
** to a value between 0 and 10000 to indicate the permyriadage progress of
|
||||
** stage 2. A value of 5000 indicates that stage 2 is half finished,
|
||||
** 9000 indicates that it is 90% finished, and so on.
|
||||
**
|
||||
** If this API is called during stage 1 of the update, output variable
|
||||
** (*pnTwo) is set to 0 to indicate that stage 2 has not yet started. The
|
||||
** value to which (*pnOne) is set depends on whether or not the RBU
|
||||
** database contains an "rbu_count" table. The rbu_count table, if it
|
||||
** exists, must contain the same columns as the following:
|
||||
**
|
||||
** CREATE TABLE rbu_count(tbl TEXT PRIMARY KEY, cnt INTEGER) WITHOUT ROWID;
|
||||
**
|
||||
** There must be one row in the table for each source (data_xxx) table within
|
||||
** the RBU database. The 'tbl' column should contain the name of the source
|
||||
** table. The 'cnt' column should contain the number of rows within the
|
||||
** source table.
|
||||
**
|
||||
** If the rbu_count table is present and populated correctly and this
|
||||
** API is called during stage 1, the *pnOne output variable is set to the
|
||||
** permyriadage progress of the same stage. If the rbu_count table does
|
||||
** not exist, then (*pnOne) is set to -1 during stage 1. If the rbu_count
|
||||
** table exists but is not correctly populated, the value of the *pnOne
|
||||
** output variable during stage 1 is undefined.
|
||||
*/
|
||||
SQLITE_API void sqlite3rbu_bp_progress(sqlite3rbu *pRbu, int *pnOne, int*pnTwo);
|
||||
|
||||
/*
|
||||
** Obtain an indication as to the current stage of an RBU update or vacuum.
|
||||
** This function always returns one of the SQLITE_RBU_STATE_XXX constants
|
||||
** defined in this file. Return values should be interpreted as follows:
|
||||
**
|
||||
** SQLITE_RBU_STATE_OAL:
|
||||
** RBU is currently building a *-oal file. The next call to sqlite3rbu_step()
|
||||
** may either add further data to the *-oal file, or compute data that will
|
||||
** be added by a subsequent call.
|
||||
**
|
||||
** SQLITE_RBU_STATE_MOVE:
|
||||
** RBU has finished building the *-oal file. The next call to sqlite3rbu_step()
|
||||
** will move the *-oal file to the equivalent *-wal path. If the current
|
||||
** operation is an RBU update, then the updated version of the database
|
||||
** file will become visible to ordinary SQLite clients following the next
|
||||
** call to sqlite3rbu_step().
|
||||
**
|
||||
** SQLITE_RBU_STATE_CHECKPOINT:
|
||||
** RBU is currently performing an incremental checkpoint. The next call to
|
||||
** sqlite3rbu_step() will copy a page of data from the *-wal file into
|
||||
** the target database file.
|
||||
**
|
||||
** SQLITE_RBU_STATE_DONE:
|
||||
** The RBU operation has finished. Any subsequent calls to sqlite3rbu_step()
|
||||
** will immediately return SQLITE_DONE.
|
||||
**
|
||||
** SQLITE_RBU_STATE_ERROR:
|
||||
** An error has occurred. Any subsequent calls to sqlite3rbu_step() will
|
||||
** immediately return the SQLite error code associated with the error.
|
||||
*/
|
||||
#define SQLITE_RBU_STATE_OAL 1
|
||||
#define SQLITE_RBU_STATE_MOVE 2
|
||||
#define SQLITE_RBU_STATE_CHECKPOINT 3
|
||||
#define SQLITE_RBU_STATE_DONE 4
|
||||
#define SQLITE_RBU_STATE_ERROR 5
|
||||
|
||||
SQLITE_API int sqlite3rbu_state(sqlite3rbu *pRbu);
|
||||
|
||||
/*
|
||||
** As part of applying an RBU update or performing an RBU vacuum operation,
|
||||
** the system must at one point move the *-oal file to the equivalent *-wal
|
||||
** path. Normally, it does this by invoking POSIX function rename(2) directly.
|
||||
** Except on WINCE platforms, where it uses win32 API MoveFileW(). This
|
||||
** function may be used to register a callback that the RBU module will invoke
|
||||
** instead of one of these APIs.
|
||||
**
|
||||
** If a callback is registered with an RBU handle, it invokes it instead
|
||||
** of rename(2) when it needs to move a file within the file-system. The
|
||||
** first argument passed to the xRename() callback is a copy of the second
|
||||
** argument (pArg) passed to this function. The second is the full path
|
||||
** to the file to move and the third the full path to which it should be
|
||||
** moved. The callback function should return SQLITE_OK to indicate
|
||||
** success. If an error occurs, it should return an SQLite error code.
|
||||
** In this case the RBU operation will be abandoned and the error returned
|
||||
** to the RBU user.
|
||||
**
|
||||
** Passing a NULL pointer in place of the xRename argument to this function
|
||||
** restores the default behaviour.
|
||||
*/
|
||||
SQLITE_API void sqlite3rbu_rename_handler(
|
||||
sqlite3rbu *pRbu,
|
||||
void *pArg,
|
||||
int (*xRename)(void *pArg, const char *zOld, const char *zNew)
|
||||
);
|
||||
|
||||
|
||||
/*
|
||||
** Create an RBU VFS named zName that accesses the underlying file-system
|
||||
** via existing VFS zParent. Or, if the zParent parameter is passed NULL,
|
||||
** then the new RBU VFS uses the default system VFS to access the file-system.
|
||||
** The new object is registered as a non-default VFS with SQLite before
|
||||
** returning.
|
||||
**
|
||||
** Part of the RBU implementation uses a custom VFS object. Usually, this
|
||||
** object is created and deleted automatically by RBU.
|
||||
**
|
||||
** The exception is for applications that also use zipvfs. In this case,
|
||||
** the custom VFS must be explicitly created by the user before the RBU
|
||||
** handle is opened. The RBU VFS should be installed so that the zipvfs
|
||||
** VFS uses the RBU VFS, which in turn uses any other VFS layers in use
|
||||
** (for example multiplexor) to access the file-system. For example,
|
||||
** to assemble an RBU enabled VFS stack that uses both zipvfs and
|
||||
** multiplexor (error checking omitted):
|
||||
**
|
||||
** // Create a VFS named "multiplex" (not the default).
|
||||
** sqlite3_multiplex_initialize(0, 0);
|
||||
**
|
||||
** // Create an rbu VFS named "rbu" that uses multiplexor. If the
|
||||
** // second argument were replaced with NULL, the "rbu" VFS would
|
||||
** // access the file-system via the system default VFS, bypassing the
|
||||
** // multiplexor.
|
||||
** sqlite3rbu_create_vfs("rbu", "multiplex");
|
||||
**
|
||||
** // Create a zipvfs VFS named "zipvfs" that uses rbu.
|
||||
** zipvfs_create_vfs_v3("zipvfs", "rbu", 0, xCompressorAlgorithmDetector);
|
||||
**
|
||||
** // Make zipvfs the default VFS.
|
||||
** sqlite3_vfs_register(sqlite3_vfs_find("zipvfs"), 1);
|
||||
**
|
||||
** Because the default VFS created above includes a RBU functionality, it
|
||||
** may be used by RBU clients. Attempting to use RBU with a zipvfs VFS stack
|
||||
** that does not include the RBU layer results in an error.
|
||||
**
|
||||
** The overhead of adding the "rbu" VFS to the system is negligible for
|
||||
** non-RBU users. There is no harm in an application accessing the
|
||||
** file-system via "rbu" all the time, even if it only uses RBU functionality
|
||||
** occasionally.
|
||||
*/
|
||||
SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent);
|
||||
|
||||
/*
|
||||
** Deregister and destroy an RBU vfs created by an earlier call to
|
||||
** sqlite3rbu_create_vfs().
|
||||
**
|
||||
** VFS objects are not reference counted. If a VFS object is destroyed
|
||||
** before all database handles that use it have been closed, the results
|
||||
** are undefined.
|
||||
*/
|
||||
SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* end of the 'extern "C"' block */
|
||||
#endif
|
||||
|
||||
#endif /* _SQLITE3RBU_H */
|
||||
@@ -0,0 +1,431 @@
|
||||
/*
|
||||
** 2015 February 16
|
||||
**
|
||||
** 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.
|
||||
**
|
||||
*************************************************************************
|
||||
*/
|
||||
|
||||
#include "sqlite3.h"
|
||||
|
||||
#if defined(SQLITE_TEST)
|
||||
#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU)
|
||||
|
||||
#include "sqlite3rbu.h"
|
||||
#include "tclsqlite.h"
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef struct TestRbu TestRbu;
|
||||
struct TestRbu {
|
||||
sqlite3rbu *pRbu;
|
||||
Tcl_Interp *interp;
|
||||
Tcl_Obj *xRename;
|
||||
};
|
||||
|
||||
/* From main.c */
|
||||
extern const char *sqlite3ErrName(int);
|
||||
extern int sqlite3TestMakePointerStr(Tcl_Interp*, char*, void*);
|
||||
|
||||
void test_rbu_delta(sqlite3_context *pCtx, int nArg, sqlite3_value **apVal){
|
||||
Tcl_Interp *interp = (Tcl_Interp*)sqlite3_user_data(pCtx);
|
||||
Tcl_Obj *pScript;
|
||||
int i;
|
||||
|
||||
pScript = Tcl_NewObj();
|
||||
Tcl_IncrRefCount(pScript);
|
||||
Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj("rbu_delta", -1));
|
||||
for(i=0; i<nArg; i++){
|
||||
sqlite3_value *pIn = apVal[i];
|
||||
const char *z = (const char*)sqlite3_value_text(pIn);
|
||||
Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj(z, -1));
|
||||
}
|
||||
|
||||
if( TCL_OK==Tcl_EvalObjEx(interp, pScript, TCL_GLOBAL_ONLY) ){
|
||||
const char *z = Tcl_GetStringResult(interp);
|
||||
sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
|
||||
}else{
|
||||
Tcl_BackgroundError(interp);
|
||||
}
|
||||
|
||||
Tcl_DecrRefCount(pScript);
|
||||
}
|
||||
|
||||
static int xRenameCallback(void *pArg, const char *zOld, const char *zNew){
|
||||
int rc = SQLITE_OK;
|
||||
TestRbu *pTest = (TestRbu*)pArg;
|
||||
Tcl_Obj *pEval = Tcl_DuplicateObj(pTest->xRename);
|
||||
|
||||
Tcl_IncrRefCount(pEval);
|
||||
Tcl_ListObjAppendElement(pTest->interp, pEval, Tcl_NewStringObj(zOld, -1));
|
||||
Tcl_ListObjAppendElement(pTest->interp, pEval, Tcl_NewStringObj(zNew, -1));
|
||||
|
||||
rc = Tcl_EvalObjEx(pTest->interp, pEval, TCL_GLOBAL_ONLY);
|
||||
Tcl_DecrRefCount(pEval);
|
||||
|
||||
return rc ? SQLITE_IOERR : SQLITE_OK;
|
||||
}
|
||||
|
||||
static int SQLITE_TCLAPI test_sqlite3rbu_cmd(
|
||||
ClientData clientData,
|
||||
Tcl_Interp *interp,
|
||||
int objc,
|
||||
Tcl_Obj *CONST objv[]
|
||||
){
|
||||
int ret = TCL_OK;
|
||||
TestRbu *pTest = (TestRbu*)clientData;
|
||||
sqlite3rbu *pRbu = pTest->pRbu;
|
||||
struct RbuCmd {
|
||||
const char *zName;
|
||||
int nArg;
|
||||
const char *zUsage;
|
||||
} aCmd[] = {
|
||||
{"step", 2, ""}, /* 0 */
|
||||
{"close", 2, ""}, /* 1 */
|
||||
{"create_rbu_delta", 2, ""}, /* 2 */
|
||||
{"savestate", 2, ""}, /* 3 */
|
||||
{"dbMain_eval", 3, "SQL"}, /* 4 */
|
||||
{"bp_progress", 2, ""}, /* 5 */
|
||||
{"db", 3, "RBU"}, /* 6 */
|
||||
{"state", 2, ""}, /* 7 */
|
||||
{"progress", 2, ""}, /* 8 */
|
||||
{"close_no_error", 2, ""}, /* 9 */
|
||||
{"temp_size_limit", 3, "LIMIT"}, /* 10 */
|
||||
{"temp_size", 2, ""}, /* 11 */
|
||||
{"dbRbu_eval", 3, "SQL"}, /* 12 */
|
||||
{"rename_handler", 3, "SCRIPT"},/* 13 */
|
||||
{0,0,0}
|
||||
};
|
||||
int iCmd;
|
||||
|
||||
if( objc<2 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "METHOD");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
ret = Tcl_GetIndexFromObjStruct(
|
||||
interp, objv[1], aCmd, sizeof(aCmd[0]), "method", 0, &iCmd
|
||||
);
|
||||
if( ret ) return TCL_ERROR;
|
||||
if( objc!=aCmd[iCmd].nArg ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, aCmd[iCmd].zUsage);
|
||||
return TCL_ERROR;
|
||||
}
|
||||
|
||||
switch( iCmd ){
|
||||
case 0: /* step */ {
|
||||
int rc = sqlite3rbu_step(pRbu);
|
||||
Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
|
||||
break;
|
||||
}
|
||||
|
||||
case 9: /* close_no_error */
|
||||
case 1: /* close */ {
|
||||
char *zErrmsg = 0;
|
||||
int rc;
|
||||
Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
|
||||
if( iCmd==1 ){
|
||||
rc = sqlite3rbu_close(pRbu, &zErrmsg);
|
||||
}else{
|
||||
rc = sqlite3rbu_close(pRbu, 0);
|
||||
}
|
||||
if( rc==SQLITE_OK || rc==SQLITE_DONE ){
|
||||
Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
|
||||
assert( zErrmsg==0 );
|
||||
}else{
|
||||
Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
|
||||
if( zErrmsg ){
|
||||
Tcl_AppendResult(interp, " - ", zErrmsg, NULL);
|
||||
sqlite3_free(zErrmsg);
|
||||
}
|
||||
ret = TCL_ERROR;
|
||||
}
|
||||
if( pTest->xRename ) Tcl_DecrRefCount(pTest->xRename);
|
||||
ckfree(pTest);
|
||||
break;
|
||||
}
|
||||
|
||||
case 2: /* create_rbu_delta */ {
|
||||
sqlite3 *db = sqlite3rbu_db(pRbu, 0);
|
||||
int rc = sqlite3_create_function(
|
||||
db, "rbu_delta", -1, SQLITE_UTF8, (void*)interp, test_rbu_delta, 0, 0
|
||||
);
|
||||
Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
|
||||
ret = (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
|
||||
break;
|
||||
}
|
||||
|
||||
case 3: /* savestate */ {
|
||||
int rc = sqlite3rbu_savestate(pRbu);
|
||||
Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
|
||||
ret = (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
|
||||
break;
|
||||
}
|
||||
|
||||
case 12: /* dbRbu_eval */
|
||||
case 4: /* dbMain_eval */ {
|
||||
sqlite3 *db = sqlite3rbu_db(pRbu, (iCmd==12));
|
||||
int rc = sqlite3_exec(db, Tcl_GetString(objv[2]), 0, 0, 0);
|
||||
if( rc!=SQLITE_OK ){
|
||||
Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3_errmsg(db), -1));
|
||||
ret = TCL_ERROR;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 5: /* bp_progress */ {
|
||||
int one, two;
|
||||
Tcl_Obj *pObj;
|
||||
sqlite3rbu_bp_progress(pRbu, &one, &two);
|
||||
|
||||
pObj = Tcl_NewObj();
|
||||
Tcl_ListObjAppendElement(interp, pObj, Tcl_NewIntObj(one));
|
||||
Tcl_ListObjAppendElement(interp, pObj, Tcl_NewIntObj(two));
|
||||
Tcl_SetObjResult(interp, pObj);
|
||||
break;
|
||||
}
|
||||
|
||||
case 6: /* db */ {
|
||||
int bArg;
|
||||
if( Tcl_GetBooleanFromObj(interp, objv[2], &bArg) ){
|
||||
ret = TCL_ERROR;
|
||||
}else{
|
||||
char zBuf[50];
|
||||
sqlite3 *db = sqlite3rbu_db(pRbu, bArg);
|
||||
if( sqlite3TestMakePointerStr(interp, zBuf, (void*)db) ){
|
||||
ret = TCL_ERROR;
|
||||
}else{
|
||||
Tcl_SetResult(interp, zBuf, TCL_VOLATILE);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 7: /* state */ {
|
||||
const char *aRes[] = { 0, "oal", "move", "checkpoint", "done", "error" };
|
||||
int eState = sqlite3rbu_state(pRbu);
|
||||
assert( eState>0 && eState<=5 );
|
||||
Tcl_SetResult(interp, (char*)aRes[eState], TCL_STATIC);
|
||||
break;
|
||||
}
|
||||
case 8: /* progress */ {
|
||||
sqlite3_int64 nStep = sqlite3rbu_progress(pRbu);
|
||||
Tcl_SetObjResult(interp, Tcl_NewWideIntObj(nStep));
|
||||
break;
|
||||
}
|
||||
|
||||
case 10: /* temp_size_limit */ {
|
||||
sqlite3_int64 nLimit;
|
||||
if( Tcl_GetWideIntFromObj(interp, objv[2], &nLimit) ){
|
||||
ret = TCL_ERROR;
|
||||
}else{
|
||||
nLimit = sqlite3rbu_temp_size_limit(pRbu, nLimit);
|
||||
Tcl_SetObjResult(interp, Tcl_NewWideIntObj(nLimit));
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 11: /* temp_size */ {
|
||||
sqlite3_int64 sz = sqlite3rbu_temp_size(pRbu);
|
||||
Tcl_SetObjResult(interp, Tcl_NewWideIntObj(sz));
|
||||
break;
|
||||
}
|
||||
|
||||
case 13: /* rename_handler */ {
|
||||
Tcl_Obj *pScript = objv[2];
|
||||
assert( !sqlite3_stricmp(aCmd[13].zName, "rename_handler") );
|
||||
if( Tcl_GetCharLength(pScript)==0 ){
|
||||
sqlite3rbu_rename_handler(pRbu, 0, 0);
|
||||
}else{
|
||||
pTest->xRename = Tcl_DuplicateObj(pScript);
|
||||
Tcl_IncrRefCount(pTest->xRename);
|
||||
sqlite3rbu_rename_handler(pRbu, pTest, xRenameCallback);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default: /* seems unlikely */
|
||||
assert( !"cannot happen" );
|
||||
break;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void createRbuWrapper(
|
||||
Tcl_Interp *interp,
|
||||
const char *zCmd,
|
||||
sqlite3rbu *pRbu
|
||||
){
|
||||
TestRbu *pTest = (TestRbu*)ckalloc(sizeof(TestRbu));
|
||||
memset(pTest, 0, sizeof(TestRbu));
|
||||
pTest->pRbu = pRbu;
|
||||
pTest->interp = interp;
|
||||
Tcl_CreateObjCommand(interp, zCmd, test_sqlite3rbu_cmd, (ClientData)pTest, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
** Tclcmd: sqlite3rbu CMD <target-db> <rbu-db> ?<state-db>?
|
||||
*/
|
||||
static int SQLITE_TCLAPI test_sqlite3rbu(
|
||||
ClientData clientData,
|
||||
Tcl_Interp *interp,
|
||||
int objc,
|
||||
Tcl_Obj *CONST objv[]
|
||||
){
|
||||
sqlite3rbu *pRbu = 0;
|
||||
const char *zCmd;
|
||||
const char *zTarget;
|
||||
const char *zRbu;
|
||||
const char *zStateDb = 0;
|
||||
|
||||
if( objc!=4 && objc!=5 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "NAME TARGET-DB RBU-DB ?STATE-DB?");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
zCmd = Tcl_GetString(objv[1]);
|
||||
zTarget = Tcl_GetString(objv[2]);
|
||||
zRbu = Tcl_GetString(objv[3]);
|
||||
if( objc==5 ) zStateDb = Tcl_GetString(objv[4]);
|
||||
|
||||
pRbu = sqlite3rbu_open(zTarget, zRbu, zStateDb);
|
||||
createRbuWrapper(interp, zCmd, pRbu);
|
||||
Tcl_SetObjResult(interp, objv[1]);
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** Tclcmd: sqlite3rbu_vacuum CMD <target-db> <state-db>
|
||||
*/
|
||||
static int SQLITE_TCLAPI test_sqlite3rbu_vacuum(
|
||||
ClientData clientData,
|
||||
Tcl_Interp *interp,
|
||||
int objc,
|
||||
Tcl_Obj *CONST objv[]
|
||||
){
|
||||
sqlite3rbu *pRbu = 0;
|
||||
const char *zCmd;
|
||||
const char *zTarget;
|
||||
const char *zStateDb = 0;
|
||||
|
||||
if( objc!=3 && objc!=4 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "NAME TARGET-DB ?STATE-DB?");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
zCmd = Tcl_GetString(objv[1]);
|
||||
zTarget = Tcl_GetString(objv[2]);
|
||||
if( objc==4 ) zStateDb = Tcl_GetString(objv[3]);
|
||||
if( zStateDb && zStateDb[0]=='\0' ) zStateDb = 0;
|
||||
|
||||
pRbu = sqlite3rbu_vacuum(zTarget, zStateDb);
|
||||
createRbuWrapper(interp, zCmd, pRbu);
|
||||
Tcl_SetObjResult(interp, objv[1]);
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** Tclcmd: sqlite3rbu_create_vfs ?-default? NAME PARENT
|
||||
*/
|
||||
static int SQLITE_TCLAPI test_sqlite3rbu_create_vfs(
|
||||
ClientData clientData,
|
||||
Tcl_Interp *interp,
|
||||
int objc,
|
||||
Tcl_Obj *CONST objv[]
|
||||
){
|
||||
const char *zName;
|
||||
const char *zParent;
|
||||
int rc;
|
||||
|
||||
if( objc!=3 && objc!=4 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "?-default? NAME PARENT");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
|
||||
zName = Tcl_GetString(objv[objc-2]);
|
||||
zParent = Tcl_GetString(objv[objc-1]);
|
||||
if( zParent[0]=='\0' ) zParent = 0;
|
||||
|
||||
rc = sqlite3rbu_create_vfs(zName, zParent);
|
||||
if( rc!=SQLITE_OK ){
|
||||
Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
|
||||
return TCL_ERROR;
|
||||
}else if( objc==4 ){
|
||||
sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
|
||||
sqlite3_vfs_register(pVfs, 1);
|
||||
}
|
||||
|
||||
Tcl_ResetResult(interp);
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** Tclcmd: sqlite3rbu_destroy_vfs NAME
|
||||
*/
|
||||
static int SQLITE_TCLAPI test_sqlite3rbu_destroy_vfs(
|
||||
ClientData clientData,
|
||||
Tcl_Interp *interp,
|
||||
int objc,
|
||||
Tcl_Obj *CONST objv[]
|
||||
){
|
||||
const char *zName;
|
||||
|
||||
if( objc!=2 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "NAME");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
|
||||
zName = Tcl_GetString(objv[1]);
|
||||
sqlite3rbu_destroy_vfs(zName);
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** Tclcmd: sqlite3rbu_internal_test
|
||||
*/
|
||||
static int SQLITE_TCLAPI test_sqlite3rbu_internal_test(
|
||||
ClientData clientData,
|
||||
Tcl_Interp *interp,
|
||||
int objc,
|
||||
Tcl_Obj *CONST objv[]
|
||||
){
|
||||
sqlite3 *db;
|
||||
|
||||
if( objc!=1 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
|
||||
db = sqlite3rbu_db(0, 0);
|
||||
if( db!=0 ){
|
||||
Tcl_AppendResult(interp, "sqlite3rbu_db(0, 0)!=0", NULL);
|
||||
return TCL_ERROR;
|
||||
}
|
||||
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
int SqliteRbu_Init(Tcl_Interp *interp){
|
||||
static struct {
|
||||
char *zName;
|
||||
Tcl_ObjCmdProc *xProc;
|
||||
} aObjCmd[] = {
|
||||
{ "sqlite3rbu", test_sqlite3rbu },
|
||||
{ "sqlite3rbu_vacuum", test_sqlite3rbu_vacuum },
|
||||
{ "sqlite3rbu_create_vfs", test_sqlite3rbu_create_vfs },
|
||||
{ "sqlite3rbu_destroy_vfs", test_sqlite3rbu_destroy_vfs },
|
||||
{ "sqlite3rbu_internal_test", test_sqlite3rbu_internal_test },
|
||||
};
|
||||
int i;
|
||||
for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
|
||||
Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
|
||||
}
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
#else
|
||||
#include "tclsqlite.h"
|
||||
int SqliteRbu_Init(Tcl_Interp *interp){ return TCL_OK; }
|
||||
#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU) */
|
||||
#endif /* defined(SQLITE_TEST) */
|
||||
Reference in new issue
Block a user