ext/rbu/rbu1.test

   1 # 2014 August 30
   2 #
   3 # The author disclaims copyright to this source code.  In place of
   4 # a legal notice, here is a blessing:
   5 #
   6 #    May you do good and not evil.
   7 #    May you find forgiveness for yourself and forgive others.
   8 #    May you share freely, never taking more than you give.
   9 #
  10 #***********************************************************************
  11 #
  12
  13 source [file join [file dirname [info script]] rbu_common.tcl]
  14 if_no_rbu_support { finish_test ; return }
  15 set ::testprefix rbu1
  16
  17 db close
  18
  19 # Create a simple RBU database. That expects to write to a table:
  20 #
  21 #   CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
  22 #
  23 proc create_rbu1 {filename} {
  24   forcedelete $filename
  25   sqlite3 rbu1 $filename
  26   rbu1 eval {
  27     CREATE TABLE data_t1(a, b, c, rbu_control);
  28     INSERT INTO data_t1 VALUES(1, 2, 3, 0);
  29     INSERT INTO data_t1 VALUES(2, 'two', 'three', 0);
  30     INSERT INTO data_t1 VALUES(3, NULL, 8.2, 0);
  31   }
  32   rbu1 close
  33   return $filename
  34 }
  35
  36 # Create a simple RBU database. That expects to write to a table:
  37 #
  38 #   CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
  39 #
  40 # This RBU includes both insert and delete operations.
  41 #
  42 proc create_rbu4 {filename} {
  43   forcedelete $filename
  44   sqlite3 rbu1 $filename
  45   rbu1 eval {
  46     CREATE TABLE data_t1(a, b, c, rbu_control);
  47     INSERT INTO data_t1 VALUES(1, 2, 3, 0);
  48     INSERT INTO data_t1 VALUES(2, NULL, 5, 1);
  49     INSERT INTO data_t1 VALUES(3, 8, 9, 0);
  50     INSERT INTO data_t1 VALUES(4, NULL, 11, 1);
  51   }
  52   rbu1 close
  53   return $filename
  54 }
  55 #
  56 # Create a simple RBU database. That expects to write to a table:
  57 #
  58 #   CREATE TABLE t1(c, b, '(a)' INTEGER PRIMARY KEY);
  59 #
  60 # This RBU includes both insert and delete operations.
  61 #
  62 proc create_rbu4b {filename} {
  63   forcedelete $filename
  64   sqlite3 rbu1 $filename
  65   rbu1 eval {
  66     CREATE TABLE data_t1(c, b, '(a)', rbu_control);
  67     INSERT INTO data_t1 VALUES(3, 2, 1, 0);
  68     INSERT INTO data_t1 VALUES(5, NULL, 2, 1);
  69     INSERT INTO data_t1 VALUES(9, 8, 3, 0);
  70     INSERT INTO data_t1 VALUES(11, NULL, 4, 1);
  71   }
  72   rbu1 close
  73   return $filename
  74 }
  75
  76 # Create a simple RBU database. That expects to write to a table:
  77 #
  78 #   CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
  79 #
  80 # This RBU includes update statements.
  81 #
  82 proc create_rbu5 {filename} {
  83   forcedelete $filename
  84   sqlite3 rbu5 $filename
  85   rbu5 eval {
  86     CREATE TABLE data_t1(a, b, c, d, rbu_control);
  87     INSERT INTO data_t1 VALUES(1, NULL, NULL, 5, '...x');  -- SET d = 5
  88     INSERT INTO data_t1 VALUES(2, NULL, 10, 5, '..xx');    -- SET c=10, d = 5
  89     INSERT INTO data_t1 VALUES(3, 11, NULL, NULL, '.x..'); -- SET b=11
  90   }
  91   rbu5 close
  92   return $filename
  93 }
  94
  95
  96 # Same as [step_rbu], except using a URI to open the target db.
  97 #
  98 proc step_rbu_uri {target rbu} {
  99   while 1 {
 100     sqlite3rbu rbu file:$target?xyz=&abc=123 $rbu
 101     set rc [rbu step]
 102     rbu close
 103     if {$rc != "SQLITE_OK"} break
 104   }
 105   set rc
 106 }
 107
 108 # Same as [step_rbu], except using an external state database - "state.db"
 109 #
 110 proc step_rbu_state {target rbu} {
 111   while 1 {
 112     sqlite3rbu rbu $target $rbu state.db
 113     set rc [rbu step]
 114     rbu close
 115     if {$rc != "SQLITE_OK"} break
 116   }
 117   set rc
 118 }
 119
 120 proc dbfilecksum {file} {
 121   sqlite3 ck $file
 122   set cksum [dbcksum ck main]
 123   ck close
 124   set cksum
 125 }
 126
 127 foreach {tn3 create_vfs destroy_vfs} {
 128   1 {} {}
 129   2 {
 130     sqlite3rbu_create_vfs -default myrbu ""
 131   } {
 132     sqlite3rbu_destroy_vfs myrbu
 133   }
 134   3 {
 135     sqlite3_register_cksumvfs
 136   } {
 137     sqlite3_unregister_cksumvfs
 138   }
 139 } {
 140
 141   eval $create_vfs
 142
 143   foreach {tn2 cmd} {
 144       1 run_rbu
 145       2 step_rbu 3 step_rbu_uri 4 step_rbu_state
 146       5 step_rbu_legacy
 147   } {
 148     foreach {tn schema} {
 149       1 {
 150         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 151       }
 152       2 {
 153         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 154         CREATE INDEX i1 ON t1(b);
 155       }
 156       3 {
 157         CREATE TABLE t1(a PRIMARY KEY, b, c) WITHOUT ROWID;
 158       }
 159       4 {
 160         CREATE TABLE t1(a PRIMARY KEY, b, c) WITHOUT ROWID;
 161         CREATE INDEX i1 ON t1(b);
 162       }
 163       5 {
 164         CREATE TABLE t1(a, b, c, PRIMARY KEY(a, c)) WITHOUT ROWID;
 165         CREATE INDEX i1 ON t1(b);
 166       }
 167       6 {
 168         CREATE TABLE t1(a, b, c, PRIMARY KEY(c)) WITHOUT ROWID;
 169         CREATE INDEX i1 ON t1(b, a);
 170       }
 171       7 {
 172         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 173         CREATE INDEX i1 ON t1(b, c);
 174         CREATE INDEX i2 ON t1(c, b);
 175         CREATE INDEX i3 ON t1(a, b, c, a, b, c);
 176       }
 177
 178       8 {
 179         CREATE TABLE t1(a PRIMARY KEY, b, c);
 180         CREATE INDEX i1 ON t1(b, c);
 181         CREATE INDEX i2 ON t1(c, b);
 182         CREATE INDEX i3 ON t1(a, b, c, a, b, c);
 183       }
 184
 185       9 {
 186         CREATE TABLE t1(a, b, c, PRIMARY KEY(a, c));
 187         CREATE INDEX i1 ON t1(b);
 188       }
 189
 190       10 {
 191         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 192         CREATE INDEX i1 ON t1(b DESC);
 193       }
 194
 195       11 {
 196         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 197         CREATE INDEX i1 ON t1(b DESC, a ASC, c DESC);
 198       }
 199
 200       12 {
 201         CREATE TABLE t1(a INT PRIMARY KEY DESC, b, c) WITHOUT ROWID;
 202       }
 203
 204       13 {
 205         CREATE TABLE t1(a INT, b, c, PRIMARY KEY(a DESC)) WITHOUT ROWID;
 206       }
 207
 208       14 {
 209         CREATE TABLE t1(a, b, c, PRIMARY KEY(a DESC, c)) WITHOUT ROWID;
 210         CREATE INDEX i1 ON t1(b);
 211       }
 212
 213       15 {
 214         CREATE TABLE t1(a, b, c, PRIMARY KEY(a, c DESC)) WITHOUT ROWID;
 215         CREATE INDEX i1 ON t1(b);
 216       }
 217
 218       16 {
 219         CREATE TABLE t1(a, b, c, PRIMARY KEY(c DESC, a)) WITHOUT ROWID;
 220         CREATE INDEX i1 ON t1(b DESC, c, a);
 221       }
 222     } {
 223       reset_db
 224       execsql $schema
 225       create_rbu1 rbu.db
 226       set check [dbfilecksum rbu.db]
 227       forcedelete state.db
 228
 229       do_test $tn3.1.$tn2.$tn.1 {
 230         $cmd test.db rbu.db
 231       } {SQLITE_DONE}
 232
 233       do_execsql_test $tn3.1.$tn2.$tn.2 { SELECT * FROM t1 ORDER BY a ASC } {
 234         1 2 3
 235         2 two three
 236         3 {} 8.2
 237       }
 238       do_execsql_test $tn3.1.$tn2.$tn.3 { SELECT * FROM t1 ORDER BY b ASC } {
 239         3 {} 8.2
 240         1 2 3
 241         2 two three
 242       }
 243       do_execsql_test $tn3.1.$tn2.$tn.4 { SELECT * FROM t1 ORDER BY c ASC } {
 244         1 2 3
 245         3 {} 8.2
 246         2 two three
 247       }
 248
 249       do_execsql_test $tn3.1.$tn2.$tn.5 { PRAGMA integrity_check } ok
 250
 251       if {$cmd=="step_rbu_state"} {
 252         do_test $tn3.1.$tn2.$tn.6 { file exists state.db } 1
 253         do_test $tn3.1.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 1
 254       } else {
 255         do_test $tn3.1.$tn2.$tn.8 { file exists state.db } 0
 256         do_test $tn3.1.$tn2.$tn.9 { expr {$check == [dbfilecksum rbu.db]} } 0
 257       }
 258     }
 259   }
 260
 261   #-------------------------------------------------------------------------
 262   # Check that an RBU cannot be applied to a table that has no PK.
 263   #
 264   # UPDATE: At one point RBU required that all tables featured either
 265   # explicit IPK columns or were declared WITHOUT ROWID. This has been
 266   # relaxed so that external PRIMARY KEYs on tables with automatic rowids
 267   # are now allowed.
 268   #
 269   # UPDATE 2: Tables without any PRIMARY KEY declaration are now allowed.
 270   # However the input table must feature an "rbu_rowid" column.
 271   #
 272   reset_db
 273   create_rbu1 rbu.db
 274   do_execsql_test $tn3.2.1 { CREATE TABLE t1(a, b, c) }
 275   do_test $tn3.2.2 {
 276     sqlite3rbu rbu test.db rbu.db
 277     rbu step
 278   } {SQLITE_ERROR}
 279   do_test $tn3.2.3 {
 280     list [catch { rbu close } msg] $msg
 281   } {1 {SQLITE_ERROR - table data_t1 requires rbu_rowid column}}
 282   reset_db
 283   do_execsql_test $tn3.2.4 { CREATE TABLE t1(a PRIMARY KEY, b, c) }
 284   do_test $tn3.2.5 {
 285     sqlite3rbu rbu test.db rbu.db
 286     rbu step
 287   } {SQLITE_OK}
 288   do_test $tn3.2.6 {
 289     list [catch { rbu close } msg] $msg
 290   } {0 SQLITE_OK}
 291
 292   #-------------------------------------------------------------------------
 293   # Check that if a UNIQUE constraint is violated the current and all
 294   # subsequent [rbu step] calls return SQLITE_CONSTRAINT. And that the RBU
 295   # transaction is rolled back by the [rbu close] that deletes the rbu
 296   # handle.
 297   #
 298   foreach {tn errcode errmsg schema} {
 299     1 SQLITE_CONSTRAINT "UNIQUE constraint failed: t1.a" {
 300       CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 301       INSERT INTO t1 VALUES(3, 2, 1);
 302     }
 303
 304     2 SQLITE_CONSTRAINT "UNIQUE constraint failed: t1.c" {
 305       CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c UNIQUE);
 306       INSERT INTO t1 VALUES(4, 2, 'three');
 307     }
 308
 309     3 SQLITE_CONSTRAINT "UNIQUE constraint failed: t1.a" {
 310       CREATE TABLE t1(a PRIMARY KEY, b, c);
 311       INSERT INTO t1 VALUES(3, 2, 1);
 312     }
 313
 314     4 SQLITE_CONSTRAINT "UNIQUE constraint failed: t1.c" {
 315       CREATE TABLE t1(a PRIMARY KEY, b, c UNIQUE);
 316       INSERT INTO t1 VALUES(4, 2, 'three');
 317     }
 318
 319   } {
 320     reset_db
 321     execsql $schema
 322     set cksum [dbcksum db main]
 323
 324     do_test $tn3.3.$tn.1 {
 325       create_rbu1 rbu.db
 326       sqlite3rbu rbu test.db rbu.db
 327       while {[set res [rbu step]]=="SQLITE_OK"} {}
 328       set res
 329     } $errcode
 330
 331     do_test $tn3.3.$tn.2 { rbu step } $errcode
 332
 333     do_test $tn3.3.$tn.3 {
 334       list [catch { rbu close } msg] $msg
 335     } [list 1 "$errcode - $errmsg"]
 336
 337     do_test $tn3.3.$tn.4 { dbcksum db main } $cksum
 338   }
 339
 340   #-------------------------------------------------------------------------
 341   #
 342   foreach {tn2 cmd} {1 run_rbu 2 step_rbu 3 step_rbu_state } {
 343     foreach {tn schema} {
 344       1 {
 345         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 346       }
 347       2 {
 348         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 349         CREATE INDEX i1 ON t1(b);
 350       }
 351       3 {
 352         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 353         CREATE INDEX i1 ON t1(b);
 354         CREATE INDEX i2 ON t1(c, b);
 355         CREATE INDEX i3 ON t1(c, b, c);
 356       }
 357       4 {
 358         CREATE TABLE t1(a INT PRIMARY KEY, b, c) WITHOUT ROWID;
 359         CREATE INDEX i1 ON t1(b);
 360         CREATE INDEX i2 ON t1(c, b);
 361         CREATE INDEX i3 ON t1(c, b, c);
 362       }
 363       5 {
 364         CREATE TABLE t1(a INT PRIMARY KEY, b, c);
 365         CREATE INDEX i1 ON t1(b);
 366         CREATE INDEX i2 ON t1(c, b);
 367         CREATE INDEX i3 ON t1(c, b, c);
 368       }
 369
 370       6 {
 371         CREATE TABLE t1(a INT PRIMARY KEY DESC, b, c);
 372         CREATE INDEX i1 ON t1(b DESC);
 373         CREATE INDEX i2 ON t1(c, b);
 374         CREATE INDEX i3 ON t1(c DESC, b, c);
 375       }
 376       7 {
 377         CREATE TABLE t1(a INT PRIMARY KEY DESC, b, c) WITHOUT ROWID;
 378         CREATE INDEX i1 ON t1(b);
 379         CREATE INDEX i2 ON t1(c, b);
 380         CREATE INDEX i3 ON t1(c, b, c);
 381       }
 382     } {
 383       reset_db
 384       execsql $schema
 385       execsql {
 386         INSERT INTO t1 VALUES(2, 'hello', 'world');
 387         INSERT INTO t1 VALUES(4, 'hello', 'planet');
 388         INSERT INTO t1 VALUES(6, 'hello', 'xyz');
 389       }
 390
 391       create_rbu4 rbu.db
 392       set check [dbfilecksum rbu.db]
 393       forcedelete state.db
 394
 395       do_test $tn3.4.$tn2.$tn.1 {
 396         $cmd test.db rbu.db
 397       } {SQLITE_DONE}
 398
 399       do_execsql_test $tn3.4.$tn2.$tn.2 {
 400         SELECT * FROM t1 ORDER BY a ASC;
 401       } {
 402         1 2 3
 403         3 8 9
 404         6 hello xyz
 405       }
 406
 407       do_execsql_test $tn3.4.$tn2.$tn.3 { PRAGMA integrity_check } ok
 408
 409       if {$cmd=="step_rbu_state"} {
 410         do_test $tn3.4.$tn2.$tn.4 { file exists state.db } 1
 411         do_test $tn3.4.$tn2.$tn.5 { expr {$check == [dbfilecksum rbu.db]} } 1
 412       } else {
 413         do_test $tn3.4.$tn2.$tn.6 { file exists state.db } 0
 414         do_test $tn3.4.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 0
 415       }
 416     }
 417   }
 418
 419   foreach {tn2 cmd} {1 run_rbu 2 step_rbu 3 step_rbu_state} {
 420     foreach {tn schema} {
 421       1 {
 422         CREATE TABLE t1(c, b, '(a)' INTEGER PRIMARY KEY);
 423         CREATE INDEX i1 ON t1(c, b);
 424       }
 425       2 {
 426         CREATE TABLE t1(c, b, '(a)' PRIMARY KEY);
 427       }
 428       3 {
 429         CREATE TABLE t1(c, b, '(a)' PRIMARY KEY) WITHOUT ROWID;
 430       }
 431     } {
 432       reset_db
 433       execsql $schema
 434       execsql {
 435         INSERT INTO t1('(a)', b, c) VALUES(2, 'hello', 'world');
 436         INSERT INTO t1('(a)', b, c) VALUES(4, 'hello', 'planet');
 437         INSERT INTO t1('(a)', b, c) VALUES(6, 'hello', 'xyz');
 438       }
 439
 440       create_rbu4b rbu.db
 441       set check [dbfilecksum rbu.db]
 442       forcedelete state.db
 443
 444       do_test $tn3.5.$tn2.$tn.1 {
 445         $cmd test.db rbu.db
 446       } {SQLITE_DONE}
 447
 448       do_execsql_test $tn3.5.$tn2.$tn.2 {
 449         SELECT * FROM t1 ORDER BY "(a)" ASC;
 450       } {
 451         3 2 1
 452         9 8 3
 453         xyz hello 6
 454       }
 455
 456       do_execsql_test $tn3.4.$tn2.$tn.3 { PRAGMA integrity_check } ok
 457
 458       if {$cmd=="step_rbu_state"} {
 459         do_test $tn3.5.$tn2.$tn.4 { file exists state.db } 1
 460         do_test $tn3.5.$tn2.$tn.5 { expr {$check == [dbfilecksum rbu.db]} } 1
 461       } else {
 462         do_test $tn3.5.$tn2.$tn.6 { file exists state.db } 0
 463         do_test $tn3.5.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 0
 464       }
 465     }
 466   }
 467
 468   #-------------------------------------------------------------------------
 469   #
 470   foreach {tn2 cmd} {1 run_rbu 2 step_rbu 3 step_rbu_state} {
 471     foreach {tn schema} {
 472       1 {
 473         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
 474       }
 475       2 {
 476         CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c, d);
 477         CREATE INDEX i1 ON t1(d);
 478         CREATE INDEX i2 ON t1(d, c);
 479         CREATE INDEX i3 ON t1(d, c, b);
 480         CREATE INDEX i4 ON t1(b);
 481         CREATE INDEX i5 ON t1(c);
 482         CREATE INDEX i6 ON t1(c, b);
 483       }
 484       3 {
 485         CREATE TABLE t1(a PRIMARY KEY, b, c, d) WITHOUT ROWID;
 486         CREATE INDEX i1 ON t1(d);
 487         CREATE INDEX i2 ON t1(d, c);
 488         CREATE INDEX i3 ON t1(d, c, b);
 489         CREATE INDEX i4 ON t1(b);
 490         CREATE INDEX i5 ON t1(c);
 491         CREATE INDEX i6 ON t1(c, b);
 492       }
 493       4 {
 494         CREATE TABLE t1(a PRIMARY KEY, b, c, d);
 495         CREATE INDEX i1 ON t1(d);
 496         CREATE INDEX i2 ON t1(d, c);
 497         CREATE INDEX i3 ON t1(d, c, b);
 498         CREATE INDEX i4 ON t1(b);
 499         CREATE INDEX i5 ON t1(c);
 500         CREATE INDEX i6 ON t1(c, b);
 501       }
 502     } {
 503       reset_db
 504       execsql $schema
 505       execsql {
 506         INSERT INTO t1 VALUES(1, 2, 3, 4);
 507         INSERT INTO t1 VALUES(2, 5, 6, 7);
 508         INSERT INTO t1 VALUES(3, 8, 9, 10);
 509       }
 510
 511       create_rbu5 rbu.db
 512       set check [dbfilecksum rbu.db]
 513       forcedelete state.db
 514
 515       do_test $tn3.5.$tn2.$tn.1 {
 516         $cmd test.db rbu.db
 517       } {SQLITE_DONE}
 518
 519       do_execsql_test $tn3.5.$tn2.$tn.2 {
 520         SELECT * FROM t1 ORDER BY a ASC;
 521       } {
 522         1 2 3 5
 523         2 5 10 5
 524         3 11 9 10
 525       }
 526
 527       do_execsql_test $tn3.6.$tn2.$tn.3 { PRAGMA integrity_check } ok
 528
 529       if {$cmd=="step_rbu_state"} {
 530         do_test $tn3.6.$tn2.$tn.4 { file exists state.db } 1
 531         do_test $tn3.6.$tn2.$tn.5 { expr {$check == [dbfilecksum rbu.db]} } 1
 532       } else {
 533         do_test $tn3.6.$tn2.$tn.6 { file exists state.db } 0
 534         do_test $tn3.6.$tn2.$tn.7 { expr {$check == [dbfilecksum rbu.db]} } 0
 535       }
 536     }
 537   }
 538
 539   #-------------------------------------------------------------------------
 540   # Test some error cases:
 541   #
 542   #   * A virtual table with no rbu_rowid column.
 543   #   * A no-PK table with no rbu_rowid column.
 544   #   * A PK table with an rbu_rowid column.
 545   #
 546   #   6: An update string of the wrong length
 547   #
 548   ifcapable fts3 {
 549     foreach {tn schema error} {
 550        1 {
 551          CREATE TABLE t1(a, b);
 552          CREATE TABLE rbu.data_t1(a, b, rbu_control);
 553        } {SQLITE_ERROR - table data_t1 requires rbu_rowid column}
 554
 555        2 {
 556          CREATE VIRTUAL TABLE t1 USING fts4(a, b);
 557          CREATE TABLE rbu.data_t1(a, b, rbu_control);
 558        } {SQLITE_ERROR - table data_t1 requires rbu_rowid column}
 559
 560        3 {
 561          CREATE TABLE t1(a PRIMARY KEY, b);
 562          CREATE TABLE rbu.data_t1(a, b, rbu_rowid, rbu_control);
 563        } {SQLITE_ERROR - table data_t1 may not have rbu_rowid column}
 564
 565        4 {
 566          CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
 567          CREATE TABLE rbu.data_t1(a, b, rbu_rowid, rbu_control);
 568        } {SQLITE_ERROR - table data_t1 may not have rbu_rowid column}
 569
 570        5 {
 571          CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
 572          CREATE TABLE rbu.data_t1(a, b, rbu_rowid, rbu_control);
 573        } {SQLITE_ERROR - table data_t1 may not have rbu_rowid column}
 574
 575        6 {
 576          CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
 577          CREATE TABLE rbu.data_t1(a, b, rbu_control);
 578          INSERT INTO rbu.data_t1 VALUES(1, 2, 'x.x');
 579        } {SQLITE_ERROR - invalid rbu_control value}
 580
 581        7 {
 582          CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
 583          CREATE TABLE rbu.data_t1(a, b, rbu_control);
 584          INSERT INTO rbu.data_t1 VALUES(1, 2, NULL);
 585        } {SQLITE_ERROR - invalid rbu_control value}
 586
 587        8 {
 588          CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
 589          CREATE TABLE rbu.data_t1(a, b, rbu_control);
 590          INSERT INTO rbu.data_t1 VALUES(1, 2, 4);
 591        } {SQLITE_ERROR - invalid rbu_control value}
 592
 593        9 {
 594          CREATE TABLE t1(a, b PRIMARY KEY) WITHOUT ROWID;
 595          CREATE TABLE rbu.data_t1(a, b, rbu_control);
 596          INSERT INTO rbu.data_t1 VALUES(1, 2, 3);
 597        } {SQLITE_ERROR - invalid rbu_control value}
 598
 599        10 {
 600          CREATE TABLE t2(a, b);
 601          CREATE TABLE rbu.data_t1(a, b, rbu_control);
 602          INSERT INTO rbu.data_t1 VALUES(1, 2, 2);
 603        } {SQLITE_ERROR - no such table: t1}
 604
 605        11 {
 606          CREATE TABLE rbu.data_t2(a, b, rbu_control);
 607          INSERT INTO rbu.data_t2 VALUES(1, 2, 2);
 608        } {SQLITE_ERROR - no such table: t2}
 609
 610     } {
 611       reset_db
 612       forcedelete rbu.db
 613       execsql { ATTACH 'rbu.db' AS rbu }
 614       execsql $schema
 615
 616       do_test $tn3.7.$tn {
 617         list [catch { run_rbu test.db rbu.db } msg] $msg
 618       } [list 1 $error]
 619     }
 620   }
 621
 622   # Test that an RBU database containing no input tables is handled
 623   # correctly.
 624   reset_db
 625   forcedelete rbu.db
 626   do_test $tn3.8.1 {
 627     list [catch { run_rbu test.db rbu.db } msg] $msg
 628   } {0 SQLITE_DONE}
 629
 630   # Test that an RBU database containing only empty data_xxx tables is
 631   # also handled correctly.
 632   reset_db
 633   forcedelete rbu.db
 634   do_execsql_test $tn3.8.2.1 {
 635     CREATE TABLE t1(a PRIMARY KEY, b);
 636     INSERT INTO t1 VALUES(1, 2);
 637     ATTACH 'rbu.db' AS rbu;
 638     CREATE TABLE data_t1(a, b, rbu_control);
 639     DETACH rbu;
 640   }
 641   do_test $tn3.8.2.1 {
 642     list [catch { run_rbu test.db rbu.db } msg] $msg
 643   } {0 SQLITE_DONE}
 644
 645   # Test that RBU can update indexes containing NULL values.
 646   #
 647   reset_db
 648   forcedelete rbu.db
 649   do_execsql_test $tn3.9.1 {
 650     CREATE TABLE t1(a PRIMARY KEY, b, c);
 651     CREATE INDEX i1 ON t1(b, c);
 652     INSERT INTO t1 VALUES(1, 1, NULL);
 653     INSERT INTO t1 VALUES(2, NULL, 2);
 654     INSERT INTO t1 VALUES(3, NULL, NULL);
 655
 656     ATTACH 'rbu.db' AS rbu;
 657     CREATE TABLE rbu.data_t1(a, b, c, rbu_control);
 658     INSERT INTO data_t1 VALUES(1, NULL, NULL, 1);
 659     INSERT INTO data_t1 VALUES(3, NULL, NULL, 1);
 660   } {}
 661
 662   do_test $tn3.9.2 {
 663     list [catch { run_rbu test.db rbu.db } msg] $msg
 664   } {0 SQLITE_DONE}
 665
 666   do_execsql_test $tn3.9.3 {
 667     SELECT * FROM t1
 668   } {2 {} 2}
 669   do_execsql_test $tn3.9.4 { PRAGMA integrity_check } {ok}
 670
 671   catch { db close }
 672   eval $destroy_vfs
 673 }
 674
 675
 676 finish_test