Debian Codegraph @

ext/rbu/rbu1.test

raw
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