test/hook.test

   1 # 2004 Jan 14
   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 # This file implements regression tests for TCL interface to the
  12 # SQLite library.
  13 #
  14 # The focus of the tests in this file is the  following interface:
  15 #
  16 #      sqlite_commit_hook    (tests hook-1..hook-3 inclusive)
  17 #      sqlite_update_hook    (tests hook-4-*)
  18 #      sqlite_rollback_hook  (tests hook-5.*)
  19 #      sqlite_preupdate_hook  (tests hook-7..hook-12)
  20 #
  21 # $Id: hook.test,v 1.15 2009/04/07 14:14:23 danielk1977 Exp $
  22
  23 set testdir [file dirname $argv0]
  24 source $testdir/tester.tcl
  25 set ::testprefix hook
  26
  27 do_test hook-1.2 {
  28   db commit_hook
  29 } {}
  30
  31
  32 do_test hook-3.1 {
  33   set commit_cnt 0
  34   proc commit_hook {} {
  35     incr ::commit_cnt
  36     return 0
  37   }
  38   db commit_hook ::commit_hook
  39   db commit_hook
  40 } {::commit_hook}
  41 do_test hook-3.2 {
  42   set commit_cnt
  43 } {0}
  44 do_test hook-3.3 {
  45   execsql {
  46     CREATE TABLE t2(a,b);
  47   }
  48   set commit_cnt
  49 } {1}
  50 do_test hook-3.4 {
  51   execsql {
  52     INSERT INTO t2 VALUES(1,2);
  53     INSERT INTO t2 SELECT a+1, b+1 FROM t2;
  54     INSERT INTO t2 SELECT a+2, b+2 FROM t2;
  55   }
  56   set commit_cnt
  57 } {4}
  58 do_test hook-3.5 {
  59   set commit_cnt {}
  60   proc commit_hook {} {
  61     set ::commit_cnt [execsql {SELECT * FROM t2}]
  62     return 0
  63   }
  64   execsql {
  65     INSERT INTO t2 VALUES(5,6);
  66   }
  67   set commit_cnt
  68 } {1 2 2 3 3 4 4 5 5 6}
  69 do_test hook-3.6 {
  70   set commit_cnt {}
  71   proc commit_hook {} {
  72     set ::commit_cnt [execsql {SELECT * FROM t2}]
  73     return 1
  74   }
  75   catchsql {
  76     INSERT INTO t2 VALUES(6,7);
  77   }
  78 } {1 {constraint failed}}
  79 verify_ex_errcode hook-3.6b SQLITE_CONSTRAINT_COMMITHOOK
  80 do_test hook-3.7 {
  81   set ::commit_cnt
  82 } {1 2 2 3 3 4 4 5 5 6 6 7}
  83 do_test hook-3.8 {
  84   execsql {SELECT * FROM t2}
  85 } {1 2 2 3 3 4 4 5 5 6}
  86
  87 # Test turnning off the commit hook
  88 #
  89 do_test hook-3.9 {
  90   db commit_hook {}
  91   set ::commit_cnt {}
  92   execsql {
  93     INSERT INTO t2 VALUES(7,8);
  94   }
  95   set ::commit_cnt
  96 } {}
  97
  98 # Ticket #3564.
  99 #
 100 do_test hook-3.10 {
 101   forcedelete test2.db test2.db-journal
 102   sqlite3 db2 test2.db
 103   proc commit_hook {} {
 104     set y [db2 one {SELECT y FROM t3 WHERE y>10}]
 105     return [expr {$y>10}]
 106   }
 107   db2 eval {CREATE TABLE t3(x,y)}
 108   db2 commit_hook commit_hook
 109   catchsql {INSERT INTO t3 VALUES(1,2)} db2
 110   catchsql {INSERT INTO t3 VALUES(11,12)} db2
 111   catchsql {INSERT INTO t3 VALUES(3,4)} db2
 112   db2 eval {
 113     SELECT * FROM t3 ORDER BY x;
 114   }
 115 } {1 2 3 4}
 116 db2 close
 117
 118
 119 #----------------------------------------------------------------------------
 120 # Tests for the update-hook.
 121 #
 122 # 4.1.* - Very simple tests. Test that the update hook is invoked correctly
 123 #         for INSERT, DELETE and UPDATE statements, including DELETE
 124 #         statements with no WHERE clause.
 125 # 4.2.* - Check that the update-hook is invoked for rows modified by trigger
 126 #         bodies. Also that the database name is correctly reported when
 127 #         an attached database is modified.
 128 # 4.3.* - Do some sorting, grouping, compound queries, population and
 129 #         depopulation of indices, to make sure the update-hook is not
 130 #         invoked incorrectly.
 131 #
 132 # EVIDENCE-OF: R-21999-45122 The sqlite3_update_hook() interface
 133 # registers a callback function with the database connection identified
 134 # by the first argument to be invoked whenever a row is updated,
 135 # inserted or deleted in a rowid table.
 136
 137 # Simple tests
 138 do_test hook-4.1.1a {
 139   catchsql {
 140     DROP TABLE t1;
 141   }
 142   unset -nocomplain ::update_hook
 143   set ::update_hook {}
 144   db update_hook [list lappend ::update_hook]
 145   #
 146   # EVIDENCE-OF: R-24531-54682 The update hook is not invoked when
 147   # internal system tables are modified (i.e. sqlite_sequence).
 148   #
 149   execsql {
 150     CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
 151     CREATE TABLE t1w(a INT PRIMARY KEY, b) WITHOUT ROWID;
 152   }
 153   set ::update_hook
 154 } {}
 155 do_test hook-4.1.1b {
 156   execsql {
 157     INSERT INTO t1 VALUES(1, 'one');
 158     INSERT INTO t1 VALUES(2, 'two');
 159     INSERT INTO t1 VALUES(3, 'three');
 160     INSERT INTO t1w SELECT * FROM t1;
 161   }
 162 } {}
 163
 164 # EVIDENCE-OF: R-15506-57666 The second callback argument is one of
 165 # SQLITE_INSERT, SQLITE_DELETE, or SQLITE_UPDATE, depending on the
 166 # operation that caused the callback to be invoked.
 167 #
 168 # EVIDENCE-OF: R-29213-61195 The third and fourth arguments to the
 169 # callback contain pointers to the database and table name containing
 170 # the affected row.
 171 #
 172 # EVIDENCE-OF: R-30809-57812 The final callback parameter is the rowid
 173 # of the row.
 174 #
 175 do_test hook-4.1.2 {
 176   set ::update_hook {}
 177   execsql {
 178     INSERT INTO t1 VALUES(4, 'four');
 179     DELETE FROM t1 WHERE b = 'two';
 180     UPDATE t1 SET b = '' WHERE a = 1 OR a = 3;
 181     DELETE FROM t1 WHERE 1; -- Avoid the truncate optimization (for now)
 182   }
 183   set ::update_hook
 184 } [list \
 185     INSERT main t1 4 \
 186     DELETE main t1 2 \
 187     UPDATE main t1 1 \
 188     UPDATE main t1 3 \
 189     DELETE main t1 1 \
 190     DELETE main t1 3 \
 191     DELETE main t1 4 \
 192 ]
 193
 194 # EVIDENCE-OF: R-61808-14344 The sqlite3_update_hook() interface does
 195 # not fire callbacks for changes to a WITHOUT ROWID table.
 196 #
 197 # EVIDENCE-OF: R-33257-44249 The update hook is not invoked when WITHOUT
 198 # ROWID tables are modified.
 199 #
 200 do_test hook-4.1.2w {
 201   set ::update_hook {}
 202   execsql {
 203     INSERT INTO t1w VALUES(4, 'four');
 204     DELETE FROM t1w WHERE b = 'two';
 205     UPDATE t1w SET b = '' WHERE a = 1 OR a = 3;
 206     DELETE FROM t1w WHERE 1; -- Avoid the truncate optimization (for now)
 207   }
 208   set ::update_hook
 209 } {}
 210
 211 ifcapable trigger {
 212   # Update hook is not invoked for changes to sqlite_master
 213   #
 214   do_test hook-4.1.3 {
 215     set ::update_hook {}
 216     execsql {
 217       CREATE TRIGGER r1 AFTER INSERT ON t1 BEGIN SELECT RAISE(IGNORE); END;
 218     }
 219     set ::update_hook
 220   } {}
 221   do_test hook-4.1.4 {
 222     set ::update_hook {}
 223     execsql {
 224       DROP TRIGGER r1;
 225     }
 226     set ::update_hook
 227   } {}
 228
 229   set ::update_hook {}
 230   do_test hook-4.2.1 {
 231     catchsql {
 232       DROP TABLE t2;
 233     }
 234     execsql {
 235       CREATE TABLE t2(c INTEGER PRIMARY KEY, d);
 236       CREATE TRIGGER t1_trigger AFTER INSERT ON t1 BEGIN
 237         INSERT INTO t2 VALUES(new.a, new.b);
 238         UPDATE t2 SET d = d || ' via trigger' WHERE new.a = c;
 239         DELETE FROM t2 WHERE new.a = c;
 240       END;
 241     }
 242   } {}
 243   do_test hook-4.2.2 {
 244     execsql {
 245       INSERT INTO t1 VALUES(1, 'one');
 246       INSERT INTO t1 VALUES(2, 'two');
 247     }
 248     set ::update_hook
 249   } [list \
 250       INSERT main t1 1 \
 251       INSERT main t2 1 \
 252       UPDATE main t2 1 \
 253       DELETE main t2 1 \
 254       INSERT main t1 2 \
 255       INSERT main t2 2 \
 256       UPDATE main t2 2 \
 257       DELETE main t2 2 \
 258   ]
 259 } else {
 260   execsql {
 261     INSERT INTO t1 VALUES(1, 'one');
 262     INSERT INTO t1 VALUES(2, 'two');
 263   }
 264 }
 265
 266 # Update-hook + ATTACH
 267 set ::update_hook {}
 268 ifcapable attach {
 269   do_test hook-4.2.3 {
 270     forcedelete test2.db
 271     execsql {
 272       ATTACH 'test2.db' AS aux;
 273       CREATE TABLE aux.t3(a INTEGER PRIMARY KEY, b);
 274       INSERT INTO aux.t3 SELECT * FROM t1;
 275       UPDATE t3 SET b = 'two or so' WHERE a = 2;
 276       DELETE FROM t3 WHERE 1; -- Avoid the truncate optimization (for now)
 277     }
 278     set ::update_hook
 279   } [list \
 280       INSERT aux t3 1 \
 281       INSERT aux t3 2 \
 282       UPDATE aux t3 2 \
 283       DELETE aux t3 1 \
 284       DELETE aux t3 2 \
 285   ]
 286 }
 287
 288 ifcapable trigger {
 289   execsql {
 290     DROP TRIGGER t1_trigger;
 291   }
 292 }
 293
 294 # Test that other vdbe operations involving btree structures do not
 295 # incorrectly invoke the update-hook.
 296 set ::update_hook {}
 297 do_test hook-4.3.1 {
 298   execsql {
 299     CREATE INDEX t1_i ON t1(b);
 300     INSERT INTO t1 VALUES(3, 'three');
 301     UPDATE t1 SET b = '';
 302     DELETE FROM t1 WHERE a > 1;
 303   }
 304   set ::update_hook
 305 } [list \
 306     INSERT main t1 3 \
 307     UPDATE main t1 1 \
 308     UPDATE main t1 2 \
 309     UPDATE main t1 3 \
 310     DELETE main t1 2 \
 311     DELETE main t1 3 \
 312 ]
 313 set ::update_hook {}
 314 ifcapable compound&&attach {
 315   do_test hook-4.3.2 {
 316     execsql {
 317       SELECT * FROM t1 UNION SELECT * FROM t3;
 318       SELECT * FROM t1 UNION ALL SELECT * FROM t3;
 319       SELECT * FROM t1 INTERSECT SELECT * FROM t3;
 320       SELECT * FROM t1 EXCEPT SELECT * FROM t3;
 321       SELECT * FROM t1 ORDER BY b;
 322       SELECT * FROM t1 GROUP BY b;
 323     }
 324     set ::update_hook
 325   } [list]
 326 }
 327
 328 do_test hook-4.4 {
 329   execsql {
 330     CREATE TABLE t4(a UNIQUE, b);
 331     INSERT INTO t4 VALUES(1, 'a');
 332     INSERT INTO t4 VALUES(2, 'b');
 333   }
 334   set ::update_hook [list]
 335   execsql {
 336     REPLACE INTO t4 VALUES(1, 'c');
 337   }
 338   set ::update_hook
 339 } [list INSERT main t4 3 ]
 340 do_execsql_test hook-4.4.1 {
 341   SELECT * FROM t4 ORDER BY a;
 342 } {1 c 2 b}
 343 do_test hook-4.4.2 {
 344   set ::update_hook [list]
 345   execsql {
 346     PRAGMA recursive_triggers = on;
 347     REPLACE INTO t4 VALUES(1, 'd');
 348   }
 349   set ::update_hook
 350 } [list INSERT main t4 4 ]
 351 do_execsql_test hook-4.4.3 {
 352   SELECT * FROM t4 ORDER BY a;
 353 } {1 d 2 b}
 354
 355 db update_hook {}
 356 #
 357 #----------------------------------------------------------------------------
 358
 359 #----------------------------------------------------------------------------
 360 # Test the rollback-hook. The rollback-hook is a bit more complicated than
 361 # either the commit or update hooks because a rollback can happen
 362 # explicitly (an sql ROLLBACK statement) or implicitly (a constraint or
 363 # error condition).
 364 #
 365 # hook-5.1.* - Test explicit rollbacks.
 366 # hook-5.2.* - Test implicit rollbacks caused by constraint failure.
 367 #
 368 # hook-5.3.* - Test implicit rollbacks caused by IO errors.
 369 # hook-5.4.* - Test implicit rollbacks caused by malloc() failure.
 370 # hook-5.5.* - Test hot-journal rollbacks. Or should the rollback hook
 371 #              not be called for these?
 372 #
 373
 374 do_test hook-5.0 {
 375   # Configure the rollback hook to increment global variable
 376   # $::rollback_hook each time it is invoked.
 377   set ::rollback_hook 0
 378   db rollback_hook [list incr ::rollback_hook]
 379 } {}
 380
 381 # Test explicit rollbacks. Not much can really go wrong here.
 382 #
 383 do_test hook-5.1.1 {
 384   set ::rollback_hook 0
 385   execsql {
 386     BEGIN;
 387     ROLLBACK;
 388   }
 389   set ::rollback_hook
 390 } {1}
 391
 392 # Test implicit rollbacks caused by constraints.
 393 #
 394 do_test hook-5.2.1 {
 395   set ::rollback_hook 0
 396   catchsql {
 397     DROP TABLE t1;
 398     CREATE TABLE t1(a PRIMARY KEY, b);
 399     INSERT INTO t1 VALUES('one', 'I');
 400     INSERT INTO t1 VALUES('one', 'I');
 401   }
 402   set ::rollback_hook
 403 } {1}
 404 do_test hook-5.2.2 {
 405   # Check that the INSERT transaction above really was rolled back.
 406   execsql {
 407     SELECT count(*) FROM t1;
 408   }
 409 } {1}
 410
 411 #
 412 # End rollback-hook testing.
 413 #----------------------------------------------------------------------------
 414
 415 #----------------------------------------------------------------------------
 416 # Test that if a commit-hook returns non-zero (causing a rollback), the
 417 # rollback-hook is invoked.
 418 #
 419 proc commit_hook {} {
 420   lappend ::hooks COMMIT
 421   return 1
 422 }
 423 proc rollback_hook {} {
 424   lappend ::hooks ROLLBACK
 425 }
 426 do_test hook-6.1 {
 427   set ::hooks [list]
 428   db commit_hook commit_hook
 429   db rollback_hook rollback_hook
 430   catchsql {
 431     BEGIN;
 432       INSERT INTO t1 VALUES('two', 'II');
 433     COMMIT;
 434   }
 435   execsql { SELECT * FROM t1 }
 436 } {one I}
 437 do_test hook-6.2 {
 438   set ::hooks
 439 } {COMMIT ROLLBACK}
 440 unset ::hooks
 441
 442 #----------------------------------------------------------------------------
 443 # The following tests - hook-7.* - test the pre-update hook.
 444 #
 445 ifcapable !preupdate {
 446   finish_test
 447   return
 448 }
 449 #
 450 # 7.1.1 - INSERT statement.
 451 # 7.1.2 - INSERT INTO ... SELECT statement.
 452 # 7.1.3 - REPLACE INTO ... (rowid conflict)
 453 # 7.1.4 - REPLACE INTO ... (other index conflicts)
 454 # 7.1.5 - REPLACE INTO ... (both rowid and other index conflicts)
 455 #
 456 # 7.2.1 - DELETE statement.
 457 # 7.2.2 - DELETE statement that uses the truncate optimization.
 458 #
 459 # 7.3.1 - UPDATE statement.
 460 # 7.3.2 - UPDATE statement that modifies the rowid.
 461 # 7.3.3 - UPDATE OR REPLACE ... (rowid conflict).
 462 # 7.3.4 - UPDATE OR REPLACE ... (other index conflicts)
 463 # 7.3.4 - UPDATE OR REPLACE ... (both rowid and other index conflicts)
 464 #
 465 # 7.4.1 - Test that the pre-update-hook is invoked only once if a row being
 466 #         deleted is removed by a BEFORE trigger.
 467 #
 468 # 7.4.2 - Test that the pre-update-hook is invoked if a BEFORE trigger
 469 #         removes a row being updated. In this case the update hook should
 470 #         be invoked with SQLITE_INSERT as the opcode when inserting the
 471 #         new version of the row.
 472 #
 473 # TODO: Short records (those created before a column is added to a table
 474 #       using ALTER TABLE)
 475 #
 476
 477 proc do_preupdate_test {tn sql x} {
 478   set X [list]
 479   foreach elem $x {lappend X $elem}
 480   uplevel do_test $tn [list "
 481     set ::preupdate \[list\]
 482     execsql { $sql }
 483     set ::preupdate
 484   "] [list $X]
 485 }
 486
 487 proc preupdate_hook {args} {
 488   set type [lindex $args 0]
 489   eval lappend ::preupdate $args
 490   if {$type != "INSERT"} {
 491     for {set i 0} {$i < [db preupdate count]} {incr i} {
 492       lappend ::preupdate [db preupdate old $i]
 493     }
 494   }
 495   if {$type != "DELETE"} {
 496     for {set i 0} {$i < [db preupdate count]} {incr i} {
 497       set rc [catch { db preupdate new $i } v]
 498       lappend ::preupdate $v
 499     }
 500   }
 501 }
 502
 503 db close
 504 forcedelete test.db
 505 sqlite3 db test.db
 506 db preupdate hook preupdate_hook
 507
 508 # Set up a schema to use for tests 7.1.* to 7.3.*.
 509 do_execsql_test 7.0 {
 510   CREATE TABLE t1(a, b);
 511   CREATE TABLE t2(x, y);
 512   CREATE TABLE t3(i, j, UNIQUE(i));
 513
 514   INSERT INTO t2 VALUES('a', 'b');
 515   INSERT INTO t2 VALUES('c', 'd');
 516
 517   INSERT INTO t3 VALUES(4, 16);
 518   INSERT INTO t3 VALUES(5, 25);
 519   INSERT INTO t3 VALUES(6, 36);
 520 }
 521
 522 do_preupdate_test 7.1.1 {
 523   INSERT INTO t1 VALUES('x', 'y')
 524 } {INSERT main t1 1 1  x y}
 525
 526 # 7.1.2.1 does not use the xfer optimization. 7.1.2.2 does.
 527 do_preupdate_test 7.1.2.1 {
 528   INSERT INTO t1 SELECT y, x FROM t2;
 529 } {INSERT main t1 2 2 b a   INSERT main t1 3 3 d c}
 530 do_preupdate_test 7.1.2.2 {
 531   INSERT INTO t1 SELECT * FROM t2;
 532 } {INSERT main t1 4 4 a b   INSERT main t1 5 5 c d}
 533
 534 do_preupdate_test 7.1.3 {
 535   REPLACE INTO t1(rowid, a, b) VALUES(1, 1, 1);
 536 } {
 537   DELETE main t1 1 1   x y
 538   INSERT main t1 1 1   1 1
 539 }
 540
 541 do_preupdate_test 7.1.4 {
 542   REPLACE INTO t3 VALUES(4, NULL);
 543 } {
 544   DELETE main t3 1 1   4 16
 545   INSERT main t3 4 4   4 {}
 546 }
 547
 548 do_preupdate_test 7.1.5 {
 549   REPLACE INTO t3(rowid, i, j) VALUES(2, 6, NULL);
 550 } {
 551   DELETE main t3 2 2  5 25
 552   DELETE main t3 3 3  6 36
 553   INSERT main t3 2 2  6 {}
 554 }
 555
 556 do_execsql_test 7.2.0 { SELECT rowid FROM t1 } {1 2 3 4 5}
 557
 558 do_preupdate_test 7.2.1 {
 559   DELETE FROM t1 WHERE rowid = 3
 560 } {
 561   DELETE main t1 3 3  d c
 562 }
 563 do_preupdate_test 7.2.2 {
 564   DELETE FROM t1
 565 } {
 566   DELETE main t1 1 1   1 1
 567   DELETE main t1 2 2   b a
 568   DELETE main t1 4 4   a b
 569   DELETE main t1 5 5   c d
 570 }
 571
 572 do_execsql_test 7.3.0 {
 573   DELETE FROM t1;
 574   DELETE FROM t2;
 575   DELETE FROM t3;
 576
 577   INSERT INTO t2 VALUES('a', 'b');
 578   INSERT INTO t2 VALUES('c', 'd');
 579
 580   INSERT INTO t3 VALUES(4, 16);
 581   INSERT INTO t3 VALUES(5, 25);
 582   INSERT INTO t3 VALUES(6, 36);
 583 }
 584
 585 do_preupdate_test 7.3.1 {
 586   UPDATE t2 SET y = y||y;
 587 } {
 588   UPDATE main t2 1 1   a b  a bb
 589   UPDATE main t2 2 2   c d  c dd
 590 }
 591
 592 do_preupdate_test 7.3.2 {
 593   UPDATE t2 SET rowid = rowid-1;
 594 } {
 595   UPDATE main t2 1 0   a bb  a bb
 596   UPDATE main t2 2 1   c dd  c dd
 597 }
 598
 599 do_preupdate_test 7.3.3 {
 600   UPDATE OR REPLACE t2 SET rowid = 1 WHERE x = 'a'
 601 } {
 602   DELETE main t2 1 1   c dd
 603   UPDATE main t2 0 1   a bb  a bb
 604 }
 605
 606 do_preupdate_test 7.3.4.1 {
 607   UPDATE OR REPLACE t3 SET i = 5 WHERE i = 6
 608 } {
 609   DELETE main t3 2 2   5 25
 610   UPDATE main t3 3 3   6 36  5 36
 611 }
 612
 613 do_execsql_test 7.3.4.2 {
 614   INSERT INTO t3 VALUES(10, 100);
 615   SELECT rowid, * FROM t3;
 616 } {1 4 16   3 5 36   4 10 100}
 617
 618 do_preupdate_test 7.3.5 {
 619   UPDATE OR REPLACE t3 SET rowid = 1, i = 5 WHERE j = 100;
 620 } {
 621   DELETE main t3 1 1    4  16
 622   DELETE main t3 3 3    5  36
 623   UPDATE main t3 4 1   10 100  5 100
 624 }
 625
 626 do_execsql_test 7.4.1.0 {
 627   CREATE TABLE t4(a, b);
 628   INSERT INTO t4 VALUES('a', 1);
 629   INSERT INTO t4 VALUES('b', 2);
 630   INSERT INTO t4 VALUES('c', 3);
 631
 632   CREATE TRIGGER t4t BEFORE DELETE ON t4 BEGIN
 633     DELETE FROM t4 WHERE b = 1;
 634   END;
 635 }
 636
 637 do_preupdate_test 7.4.1.1 {
 638   DELETE FROM t4 WHERE b = 3
 639 } {
 640   DELETE main t4 1 1   a 1
 641   DELETE main t4 3 3   c 3
 642 }
 643
 644 do_execsql_test 7.4.1.2 {
 645   INSERT INTO t4(rowid, a, b) VALUES(1, 'a', 1);
 646   INSERT INTO t4(rowid, a, b) VALUES(3, 'c', 3);
 647 }
 648 do_preupdate_test 7.4.1.3 {
 649   DELETE FROM t4 WHERE b = 1
 650 } {
 651   DELETE main t4 1 1   a 1
 652 }
 653
 654 do_execsql_test 7.4.2.0 {
 655   CREATE TABLE t5(a, b);
 656   INSERT INTO t5 VALUES('a', 1);
 657   INSERT INTO t5 VALUES('b', 2);
 658   INSERT INTO t5 VALUES('c', 3);
 659
 660   CREATE TRIGGER t5t BEFORE UPDATE ON t5 BEGIN
 661     DELETE FROM t5 WHERE b = 1;
 662   END;
 663 }
 664 do_preupdate_test 7.4.2.1 {
 665   UPDATE t5 SET b = 4 WHERE a = 'c'
 666 } {
 667   DELETE main t5 1 1   a 1
 668   UPDATE main t5 3 3   c 3  c 4
 669 }
 670
 671 do_execsql_test 7.4.2.2 {
 672   INSERT INTO t5(rowid, a, b) VALUES(1, 'a', 1);
 673 }
 674
 675 do_preupdate_test 7.4.2.3 {
 676   UPDATE t5 SET b = 5 WHERE a = 'a'
 677 } {
 678   DELETE main t5 1 1   a 1
 679 }
 680
 681 ifcapable altertable {
 682   do_execsql_test 7.5.1.0 {
 683     CREATE TABLE t7(a, b);
 684     INSERT INTO t7 VALUES('one', 'two');
 685     INSERT INTO t7 VALUES('three', 'four');
 686     ALTER TABLE t7 ADD COLUMN c DEFAULT NULL;
 687   }
 688
 689   do_preupdate_test 7.5.1.1 {
 690     DELETE FROM t7 WHERE a = 'one'
 691   } {
 692     DELETE main t7 1 1   one two {}
 693   }
 694
 695   do_preupdate_test 7.5.1.2 {
 696     UPDATE t7 SET b = 'five'
 697   } {
 698     UPDATE main t7 2 2   three four {}  three five {}
 699   }
 700
 701   do_execsql_test 7.5.2.0 {
 702     CREATE TABLE t8(a, b);
 703     INSERT INTO t8 VALUES('one', 'two');
 704     INSERT INTO t8 VALUES('three', 'four');
 705     ALTER TABLE t8 ADD COLUMN c DEFAULT 'xxx';
 706   }
 707 }
 708
 709 if 0 {
 710   # At time of writing, these two are broken. They demonstrate that the
 711   # sqlite3_preupdate_old() method does not handle the case where ALTER TABLE
 712   # has been used to add a column with a default value other than NULL.
 713   #
 714   do_preupdate_test 7.5.2.1 {
 715     DELETE FROM t8 WHERE a = 'one'
 716   } {
 717     DELETE main t8 1 1   one two xxx
 718   }
 719   do_preupdate_test 7.5.2.2 {
 720     UPDATE t8 SET b = 'five'
 721   } {
 722     UPDATE main t8 2 2   three four xxx  three five xxx
 723   }
 724 }
 725
 726 # This block of tests verifies that IPK values are correctly reported
 727 # by the sqlite3_preupdate_old() and sqlite3_preupdate_new() functions.
 728 #
 729 do_execsql_test 7.6.1 { CREATE TABLE t9(a, b INTEGER PRIMARY KEY, c) }
 730 do_preupdate_test 7.6.2 {
 731   INSERT INTO t9 VALUES(1, 2, 3);
 732   UPDATE t9 SET b = b+1, c = c+1;
 733   DELETE FROM t9 WHERE a = 1;
 734 } {
 735   INSERT main t9 2 2   1 2 3
 736   UPDATE main t9 2 3   1 2 3   1 3 4
 737   DELETE main t9 3 3   1 3 4
 738 }
 739
 740 #--------------------------------------------------------------------------
 741 # Test that the sqlite3_preupdate_depth() API seems to work.
 742 #
 743 proc preupdate_hook {args} {
 744   set type [lindex $args 0]
 745   eval lappend ::preupdate $args
 746   eval lappend ::preupdate [db preupdate depth]
 747
 748   if {$type != "INSERT"} {
 749     for {set i 0} {$i < [db preupdate count]} {incr i} {
 750       lappend ::preupdate [db preupdate old $i]
 751     }
 752   }
 753   if {$type != "DELETE"} {
 754     for {set i 0} {$i < [db preupdate count]} {incr i} {
 755       set rc [catch { db preupdate new $i } v]
 756       lappend ::preupdate $v
 757     }
 758   }
 759 }
 760
 761 db close
 762 forcedelete test.db
 763 sqlite3 db test.db
 764 db preupdate hook preupdate_hook
 765
 766 do_execsql_test 7.6.1 {
 767   CREATE TABLE t1(x PRIMARY KEY);
 768   CREATE TABLE t2(x PRIMARY KEY);
 769   CREATE TABLE t3(x PRIMARY KEY);
 770   CREATE TABLE t4(x PRIMARY KEY);
 771
 772   CREATE TRIGGER a AFTER INSERT ON t1 BEGIN INSERT INTO t2 VALUES(new.x); END;
 773   CREATE TRIGGER b AFTER INSERT ON t2 BEGIN INSERT INTO t3 VALUES(new.x); END;
 774   CREATE TRIGGER c AFTER INSERT ON t3 BEGIN INSERT INTO t4 VALUES(new.x); END;
 775
 776   CREATE TRIGGER d AFTER UPDATE ON t1 BEGIN UPDATE t2 SET x = new.x; END;
 777   CREATE TRIGGER e AFTER UPDATE ON t2 BEGIN UPDATE t3 SET x = new.x; END;
 778   CREATE TRIGGER f AFTER UPDATE ON t3 BEGIN UPDATE t4 SET x = new.x; END;
 779
 780   CREATE TRIGGER g AFTER DELETE ON t1 BEGIN DELETE FROM t2 WHERE 1; END;
 781   CREATE TRIGGER h AFTER DELETE ON t2 BEGIN DELETE FROM t3 WHERE 1; END;
 782   CREATE TRIGGER i AFTER DELETE ON t3 BEGIN DELETE FROM t4 WHERE 1; END;
 783 }
 784
 785 do_preupdate_test 7.6.2 {
 786   INSERT INTO t1 VALUES('xyz');
 787 } {
 788   INSERT main t1 1 1   0      xyz
 789   INSERT main t2 1 1   1      xyz
 790   INSERT main t3 1 1   2      xyz
 791   INSERT main t4 1 1   3      xyz
 792 }
 793 do_preupdate_test 7.6.3 {
 794   UPDATE t1 SET x = 'abc';
 795 } {
 796   UPDATE main t1 1 1   0      xyz abc
 797   UPDATE main t2 1 1   1      xyz abc
 798   UPDATE main t3 1 1   2      xyz abc
 799   UPDATE main t4 1 1   3      xyz abc
 800 }
 801 do_preupdate_test 7.6.4 {
 802   DELETE FROM t1 WHERE 1;
 803 } {
 804   DELETE main t1 1 1   0      abc
 805   DELETE main t2 1 1   1      abc
 806   DELETE main t3 1 1   2      abc
 807   DELETE main t4 1 1   3      abc
 808 }
 809
 810 do_execsql_test 7.6.5 {
 811   DROP TRIGGER a; DROP TRIGGER b; DROP TRIGGER c;
 812   DROP TRIGGER d; DROP TRIGGER e; DROP TRIGGER f;
 813   DROP TRIGGER g; DROP TRIGGER h; DROP TRIGGER i;
 814
 815   CREATE TRIGGER a BEFORE INSERT ON t1 BEGIN INSERT INTO t2 VALUES(new.x); END;
 816   CREATE TRIGGER b BEFORE INSERT ON t2 BEGIN INSERT INTO t3 VALUES(new.x); END;
 817   CREATE TRIGGER c BEFORE INSERT ON t3 BEGIN INSERT INTO t4 VALUES(new.x); END;
 818
 819   CREATE TRIGGER d BEFORE UPDATE ON t1 BEGIN UPDATE t2 SET x = new.x; END;
 820   CREATE TRIGGER e BEFORE UPDATE ON t2 BEGIN UPDATE t3 SET x = new.x; END;
 821   CREATE TRIGGER f BEFORE UPDATE ON t3 BEGIN UPDATE t4 SET x = new.x; END;
 822
 823   CREATE TRIGGER g BEFORE DELETE ON t1 BEGIN DELETE FROM t2 WHERE 1; END;
 824   CREATE TRIGGER h BEFORE DELETE ON t2 BEGIN DELETE FROM t3 WHERE 1; END;
 825   CREATE TRIGGER i BEFORE DELETE ON t3 BEGIN DELETE FROM t4 WHERE 1; END;
 826 }
 827
 828 do_preupdate_test 7.6.6 {
 829   INSERT INTO t1 VALUES('xyz');
 830 } {
 831   INSERT main t4 1 1   3      xyz
 832   INSERT main t3 1 1   2      xyz
 833   INSERT main t2 1 1   1      xyz
 834   INSERT main t1 1 1   0      xyz
 835 }
 836 do_preupdate_test 7.6.3 {
 837   UPDATE t1 SET x = 'abc';
 838 } {
 839   UPDATE main t4 1 1   3      xyz abc
 840   UPDATE main t3 1 1   2      xyz abc
 841   UPDATE main t2 1 1   1      xyz abc
 842   UPDATE main t1 1 1   0      xyz abc
 843 }
 844 do_preupdate_test 7.6.4 {
 845   DELETE FROM t1 WHERE 1;
 846 } {
 847   DELETE main t4 1 1   3      abc
 848   DELETE main t3 1 1   2      abc
 849   DELETE main t2 1 1   1      abc
 850   DELETE main t1 1 1   0      abc
 851 }
 852
 853 # No preupdate callbacks for modifying sqlite_master.
 854 ifcapable altertable {
 855   do_preupdate_test 8.1 { CREATE TABLE x1(x, y); } { }
 856   do_preupdate_test 8.2 { ALTER TABLE x1 ADD COLUMN z } { }
 857   do_preupdate_test 8.3 { ALTER TABLE x1 RENAME TO y1 } { }
 858   do_preupdate_test 8.4 { CREATE INDEX y1x ON y1(x) } { }
 859   do_preupdate_test 8.5 { CREATE VIEW v1 AS SELECT * FROM y1 } { }
 860   do_preupdate_test 8.6 { DROP TABLE y1 } { }
 861 }
 862
 863 #-------------------------------------------------------------------------
 864 reset_db
 865 db preupdate hook preupdate_hook
 866
 867 ifcapable altertable {
 868   do_execsql_test 9.0 {
 869     CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
 870     CREATE TABLE t2(a, b INTEGER PRIMARY KEY);
 871   }
 872   do_preupdate_test 9.1 {
 873     INSERT INTO t1 VALUES(456, NULL, NULL);
 874   } {
 875     INSERT main t1 456 456  0  456 {} {}
 876   }
 877   do_execsql_test 9.2 {
 878     ALTER TABLE t1 ADD COLUMN d;
 879   }
 880   do_preupdate_test 9.3 {
 881     INSERT INTO t1(a, b, c) VALUES(457, NULL, NULL);
 882   } {
 883     INSERT main t1 457 457  0  457 {} {} {}
 884   }
 885   do_preupdate_test 9.4 {
 886     DELETE FROM t1 WHERE a=456
 887   } {
 888     DELETE main t1 456 456  0  456 {} {} {}
 889   }
 890   do_preupdate_test 9.5 {
 891     INSERT INTO t2 DEFAULT VALUES;
 892   } {
 893     INSERT main t2 1 1  0  {} 1
 894   }
 895   do_preupdate_test 9.6 {
 896     INSERT INTO t1 DEFAULT VALUES;
 897   } {
 898     INSERT main t1 458 458  0  458 {} {} {}
 899   }
 900 }
 901
 902
 903 do_execsql_test 10.0 {
 904   CREATE TABLE t3(a, b INTEGER PRIMARY KEY);
 905 }
 906 do_preupdate_test 10.1 {
 907   INSERT INTO t3 DEFAULT VALUES
 908 } {
 909   INSERT main t3 1 1 0 {} 1
 910 }
 911 do_execsql_test 10.2 { SELECT * FROM t3 } {{} 1}
 912 do_preupdate_test 10.3 {
 913   DELETE FROM t3 WHERE b=1
 914 } {DELETE main t3 1 1 0 {} 1}
 915
 916 #-------------------------------------------------------------------------
 917 # Test that the "update" hook is not fired for operations on the
 918 # sqlite_stat1 table performed by ANALYZE, even if a pre-update hook is
 919 # registered.
 920 ifcapable analyze {
 921   reset_db
 922   do_execsql_test 11.1 {
 923     CREATE TABLE t1(a, b);
 924     CREATE INDEX idx1 ON t1(a);
 925     CREATE INDEX idx2 ON t1(b);
 926
 927     INSERT INTO t1 VALUES(1, 2);
 928     INSERT INTO t1 VALUES(3, 4);
 929     INSERT INTO t1 VALUES(5, 6);
 930     INSERT INTO t1 VALUES(7, 8);
 931   }
 932
 933   db preupdate hook preupdate_cb
 934   db update_hook update_cb
 935
 936   proc preupdate_cb {args} { lappend ::res "preupdate" $args }
 937   proc update_cb {args} { lappend ::res "update" $args }
 938
 939   set ::res [list]
 940   do_test 11.2 {
 941     execsql ANALYZE
 942     set ::res
 943   } [list {*}{
 944     preupdate {INSERT main sqlite_stat1 1 1}
 945     preupdate {INSERT main sqlite_stat1 2 2}
 946   }]
 947
 948   do_execsql_test 11.3 {
 949     INSERT INTO t1 VALUES(9, 10);
 950     INSERT INTO t1 VALUES(11, 12);
 951     INSERT INTO t1 VALUES(13, 14);
 952     INSERT INTO t1 VALUES(15, 16);
 953   }
 954
 955   set ::res [list]
 956   do_test 11.4 {
 957     execsql ANALYZE
 958     set ::res
 959   } [list {*}{
 960     preupdate {DELETE main sqlite_stat1 1 1}
 961     preupdate {DELETE main sqlite_stat1 2 2}
 962     preupdate {INSERT main sqlite_stat1 1 1}
 963     preupdate {INSERT main sqlite_stat1 2 2}
 964   }]
 965 }
 966
 967 #-------------------------------------------------------------------------
 968 # Test that the pre-update hook is fired for INSERT statements that use
 969 # the xfer optimization on without rowid tables.
 970 #
 971 reset_db
 972 do_execsql_test 12.1 {
 973   CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
 974   CREATE TABLE t2(a INTEGER PRIMARY KEY, b) WITHOUT ROWID;
 975
 976   INSERT INTO t1 VALUES(1, 2);
 977   INSERT INTO t1 VALUES(3, 4);
 978   INSERT INTO t2 VALUES(5, 6);
 979   INSERT INTO t2 VALUES(7, 8);
 980
 981   CREATE TABLE t3 (a INTEGER PRIMARY KEY, b) WITHOUT ROWID;
 982 }
 983
 984 db preupdate hook preupdate_cb
 985 db update_hook update_cb
 986
 987 proc preupdate_cb {args} { lappend ::res "preupdate" $args }
 988 proc update_cb {args} { lappend ::res "update" $args }
 989
 990 set ::res [list]
 991 do_test 12.2 {
 992   execsql VACUUM
 993   set ::res
 994 } {}
 995
 996 do_test 12.3 {
 997   set ::res [list]
 998   execsql { INSERT INTO t3 SELECT a, b FROM t2 }
 999   set ::res
1000 } {preupdate {INSERT main t3 0 0} preupdate {INSERT main t3 0 0}}
1001
1002 do_test 12.4 {
1003   execsql { DELETE FROM t3 }
1004   set ::res [list]
1005   execsql { INSERT INTO t3 SELECT * FROM t2 }
1006   set ::res
1007 } {preupdate {INSERT main t3 0 0} preupdate {INSERT main t3 0 0}}
1008
1009 do_execsql_test 12.5 {
1010   CREATE TABLE t4(a COLLATE nocase PRIMARY KEY, b) WITHOUT ROWID;
1011   INSERT INTO t4 VALUES('abc', 1);
1012   INSERT INTO t4 VALUES('DEF', 2);
1013 }
1014
1015 set ::res [list]
1016 do_test 12.6 {
1017   execsql VACUUM
1018   set ::res
1019 } {}
1020
1021 do_catchsql_test 12.6 {
1022   INSERT INTO t4 VALUES('def', 3);
1023 } {1 {UNIQUE constraint failed: t4.a}}
1024
1025 finish_test