| # 2001 September 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 implements regression tests for SQLite library. The |
| # focus of this file is testing the SELECT statement. |
| # |
| # $Id: autovacuum.test,v 1.29 2009/04/06 17:50:03 danielk1977 Exp $ |
| |
| set testdir [file dirname $argv0] |
| source $testdir/tester.tcl |
| |
| # If this build of the library does not support auto-vacuum, omit this |
| # whole file. |
| ifcapable {!autovacuum || !pragma} { |
| finish_test |
| return |
| } |
| |
| # Return a string $len characters long. The returned string is $char repeated |
| # over and over. For example, [make_str abc 8] returns "abcabcab". |
| proc make_str {char len} { |
| set str [string repeat $char. $len] |
| return [string range $str 0 [expr $len-1]] |
| } |
| |
| # Return the number of pages in the file test.db by looking at the file system. |
| proc file_pages {} { |
| return [expr [file size test.db] / 1024] |
| } |
| |
| #------------------------------------------------------------------------- |
| # Test cases autovacuum-1.* work as follows: |
| # |
| # 1. A table with a single indexed field is created. |
| # 2. Approximately 20 rows are inserted into the table. Each row is long |
| # enough such that it uses at least 2 overflow pages for both the table |
| # and index entry. |
| # 3. The rows are deleted in a psuedo-random order. Sometimes only one row |
| # is deleted per transaction, sometimes more than one. |
| # 4. After each transaction the table data is checked to ensure it is correct |
| # and a "PRAGMA integrity_check" is executed. |
| # 5. Once all the rows are deleted the file is checked to make sure it |
| # consists of exactly 4 pages. |
| # |
| # Steps 2-5 are repeated for a few different psuedo-random delete patterns |
| # (defined by the $delete_orders list). |
| set delete_orders [list] |
| lappend delete_orders {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20} |
| lappend delete_orders {20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1} |
| lappend delete_orders {8 18 2 4 14 11 13 3 10 7 9 5 12 17 19 15 20 6 16 1} |
| lappend delete_orders {10 3 11 17 19 20 7 4 13 6 1 14 16 12 9 18 8 15 5 2} |
| lappend delete_orders {{1 2 3 4 5 6 7 8 9 10} {11 12 13 14 15 16 17 18 19 20}} |
| lappend delete_orders {{19 8 17 15} {16 11 9 14} {18 5 3 1} {13 20 7 2} {6 12}} |
| |
| # The length of each table entry. |
| # set ENTRY_LEN 3500 |
| set ENTRY_LEN 3500 |
| |
| do_test autovacuum-1.1 { |
| execsql { |
| PRAGMA auto_vacuum = 1; |
| CREATE TABLE av1(a); |
| CREATE INDEX av1_idx ON av1(a); |
| } |
| } {} |
| |
| set tn 0 |
| foreach delete_order $delete_orders { |
| incr tn |
| |
| # Set up the table. |
| set ::tbl_data [list] |
| foreach i [lsort -integer [eval concat $delete_order]] { |
| execsql "INSERT INTO av1 (oid, a) VALUES($i, '[make_str $i $ENTRY_LEN]')" |
| lappend ::tbl_data [make_str $i $ENTRY_LEN] |
| } |
| |
| # Make sure the integrity check passes with the initial data. |
| ifcapable {integrityck} { |
| do_test autovacuum-1.$tn.1 { |
| execsql { |
| pragma integrity_check |
| } |
| } {ok} |
| } |
| |
| foreach delete $delete_order { |
| # Delete one set of rows from the table. |
| do_test autovacuum-1.$tn.($delete).1 { |
| execsql " |
| DELETE FROM av1 WHERE oid = [join $delete " OR oid = "] |
| " |
| } {} |
| |
| # Do the integrity check. |
| ifcapable {integrityck} { |
| do_test autovacuum-1.$tn.($delete).2 { |
| execsql { |
| pragma integrity_check |
| } |
| } {ok} |
| } |
| # Ensure the data remaining in the table is what was expected. |
| foreach d $delete { |
| set idx [lsearch $::tbl_data [make_str $d $ENTRY_LEN]] |
| set ::tbl_data [lreplace $::tbl_data $idx $idx] |
| } |
| do_test autovacuum-1.$tn.($delete).3 { |
| execsql { |
| select a from av1 |
| } |
| } $::tbl_data |
| } |
| |
| # All rows have been deleted. Ensure the file has shrunk to 4 pages. |
| do_test autovacuum-1.$tn.3 { |
| file_pages |
| } {4} |
| } |
| |
| #--------------------------------------------------------------------------- |
| # Tests cases autovacuum-2.* test that root pages are allocated |
| # and deallocated correctly at the start of the file. Operation is roughly as |
| # follows: |
| # |
| # autovacuum-2.1.*: Drop the tables that currently exist in the database. |
| # autovacuum-2.2.*: Create some tables. Ensure that data pages can be |
| # moved correctly to make space for new root-pages. |
| # autovacuum-2.3.*: Drop one of the tables just created (not the last one), |
| # and check that one of the other tables is moved to |
| # the free root-page location. |
| # autovacuum-2.4.*: Check that a table can be created correctly when the |
| # root-page it requires is on the free-list. |
| # autovacuum-2.5.*: Check that a table with indices can be dropped. This |
| # is slightly tricky because dropping one of the |
| # indices/table btrees could move the root-page of another. |
| # The code-generation layer of SQLite overcomes this problem |
| # by dropping the btrees in descending order of root-pages. |
| # This test ensures that this actually happens. |
| # |
| do_test autovacuum-2.1.1 { |
| execsql { |
| DROP TABLE av1; |
| } |
| } {} |
| do_test autovacuum-2.1.2 { |
| file_pages |
| } {1} |
| |
| # Create a table and put some data in it. |
| do_test autovacuum-2.2.1 { |
| execsql { |
| CREATE TABLE av1(x); |
| SELECT rootpage FROM sqlite_master ORDER BY rootpage; |
| } |
| } {3} |
| do_test autovacuum-2.2.2 { |
| execsql " |
| INSERT INTO av1 VALUES('[make_str abc 3000]'); |
| INSERT INTO av1 VALUES('[make_str def 3000]'); |
| INSERT INTO av1 VALUES('[make_str ghi 3000]'); |
| INSERT INTO av1 VALUES('[make_str jkl 3000]'); |
| " |
| set ::av1_data [db eval {select * from av1}] |
| file_pages |
| } {15} |
| |
| # Create another table. Check it is located immediately after the first. |
| # This test case moves the second page in an over-flow chain. |
| do_test autovacuum-2.2.3 { |
| execsql { |
| CREATE TABLE av2(x); |
| SELECT rootpage FROM sqlite_master ORDER BY rootpage; |
| } |
| } {3 4} |
| do_test autovacuum-2.2.4 { |
| file_pages |
| } {16} |
| |
| # Create another table. Check it is located immediately after the second. |
| # This test case moves the first page in an over-flow chain. |
| do_test autovacuum-2.2.5 { |
| execsql { |
| CREATE TABLE av3(x); |
| SELECT rootpage FROM sqlite_master ORDER BY rootpage; |
| } |
| } {3 4 5} |
| do_test autovacuum-2.2.6 { |
| file_pages |
| } {17} |
| |
| # Create another table. Check it is located immediately after the second. |
| # This test case moves a btree leaf page. |
| do_test autovacuum-2.2.7 { |
| execsql { |
| CREATE TABLE av4(x); |
| SELECT rootpage FROM sqlite_master ORDER BY rootpage; |
| } |
| } {3 4 5 6} |
| do_test autovacuum-2.2.8 { |
| file_pages |
| } {18} |
| do_test autovacuum-2.2.9 { |
| execsql { |
| select * from av1 |
| } |
| } $av1_data |
| |
| do_test autovacuum-2.3.1 { |
| execsql { |
| INSERT INTO av2 SELECT 'av1' || x FROM av1; |
| INSERT INTO av3 SELECT 'av2' || x FROM av1; |
| INSERT INTO av4 SELECT 'av3' || x FROM av1; |
| } |
| set ::av2_data [execsql {select x from av2}] |
| set ::av3_data [execsql {select x from av3}] |
| set ::av4_data [execsql {select x from av4}] |
| file_pages |
| } {54} |
| do_test autovacuum-2.3.2 { |
| execsql { |
| DROP TABLE av2; |
| SELECT rootpage FROM sqlite_master ORDER BY rootpage; |
| } |
| } {3 4 5} |
| do_test autovacuum-2.3.3 { |
| file_pages |
| } {41} |
| do_test autovacuum-2.3.4 { |
| execsql { |
| SELECT x FROM av3; |
| } |
| } $::av3_data |
| do_test autovacuum-2.3.5 { |
| execsql { |
| SELECT x FROM av4; |
| } |
| } $::av4_data |
| |
| # Drop all the tables in the file. This puts all pages except the first 2 |
| # (the sqlite_master root-page and the first pointer map page) on the |
| # free-list. |
| do_test autovacuum-2.4.1 { |
| execsql { |
| DROP TABLE av1; |
| DROP TABLE av3; |
| BEGIN; |
| DROP TABLE av4; |
| } |
| file_pages |
| } {15} |
| do_test autovacuum-2.4.2 { |
| for {set i 3} {$i<=10} {incr i} { |
| execsql "CREATE TABLE av$i (x)" |
| } |
| file_pages |
| } {15} |
| do_test autovacuum-2.4.3 { |
| execsql { |
| SELECT rootpage FROM sqlite_master ORDER by rootpage |
| } |
| } {3 4 5 6 7 8 9 10} |
| |
| # Right now there are 5 free pages in the database. Consume and then free |
| # a 520 pages. Then create 520 tables. This ensures that at least some of the |
| # desired root-pages reside on the second free-list trunk page, and that the |
| # trunk itself is required at some point. |
| do_test autovacuum-2.4.4 { |
| execsql " |
| INSERT INTO av3 VALUES ('[make_str abcde [expr 1020*520 + 500]]'); |
| DELETE FROM av3; |
| " |
| } {} |
| set root_page_list [list] |
| set pending_byte_page [expr ($::sqlite_pending_byte / 1024) + 1] |
| for {set i 3} {$i<=532} {incr i} { |
| # 207 and 412 are pointer-map pages. |
| if { $i!=207 && $i!=412 && $i != $pending_byte_page} { |
| lappend root_page_list $i |
| } |
| } |
| if {$i >= $pending_byte_page} { |
| lappend root_page_list $i |
| } |
| do_test autovacuum-2.4.5 { |
| for {set i 11} {$i<=530} {incr i} { |
| execsql "CREATE TABLE av$i (x)" |
| } |
| execsql { |
| SELECT rootpage FROM sqlite_master ORDER by rootpage |
| } |
| } $root_page_list |
| |
| # Just for fun, delete all those tables and see if the database is 1 page. |
| do_test autovacuum-2.4.6 { |
| execsql COMMIT; |
| file_pages |
| } [expr 561 + (($i >= $pending_byte_page)?1:0)] |
| integrity_check autovacuum-2.4.6 |
| do_test autovacuum-2.4.7 { |
| execsql BEGIN |
| for {set i 3} {$i<=530} {incr i} { |
| execsql "DROP TABLE av$i" |
| } |
| execsql COMMIT |
| file_pages |
| } 1 |
| |
| # Create some tables with indices to drop. |
| do_test autovacuum-2.5.1 { |
| execsql { |
| CREATE TABLE av1(a PRIMARY KEY, b, c); |
| INSERT INTO av1 VALUES('av1 a', 'av1 b', 'av1 c'); |
| |
| CREATE TABLE av2(a PRIMARY KEY, b, c); |
| CREATE INDEX av2_i1 ON av2(b); |
| CREATE INDEX av2_i2 ON av2(c); |
| INSERT INTO av2 VALUES('av2 a', 'av2 b', 'av2 c'); |
| |
| CREATE TABLE av3(a PRIMARY KEY, b, c); |
| CREATE INDEX av3_i1 ON av3(b); |
| INSERT INTO av3 VALUES('av3 a', 'av3 b', 'av3 c'); |
| |
| CREATE TABLE av4(a, b, c); |
| CREATE INDEX av4_i1 ON av4(a); |
| CREATE INDEX av4_i2 ON av4(b); |
| CREATE INDEX av4_i3 ON av4(c); |
| CREATE INDEX av4_i4 ON av4(a, b, c); |
| INSERT INTO av4 VALUES('av4 a', 'av4 b', 'av4 c'); |
| } |
| } {} |
| |
| do_test autovacuum-2.5.2 { |
| execsql { |
| SELECT name, rootpage FROM sqlite_master; |
| } |
| } [list av1 3 sqlite_autoindex_av1_1 4 \ |
| av2 5 sqlite_autoindex_av2_1 6 av2_i1 7 av2_i2 8 \ |
| av3 9 sqlite_autoindex_av3_1 10 av3_i1 11 \ |
| av4 12 av4_i1 13 av4_i2 14 av4_i3 15 av4_i4 16 \ |
| ] |
| |
| # The following 4 tests are SELECT queries that use the indices created. |
| # If the root-pages in the internal schema are not updated correctly when |
| # a table or indice is moved, these queries will fail. They are repeated |
| # after each table is dropped (i.e. as test cases 2.5.*.[1..4]). |
| do_test autovacuum-2.5.2.1 { |
| execsql { |
| SELECT * FROM av1 WHERE a = 'av1 a'; |
| } |
| } {{av1 a} {av1 b} {av1 c}} |
| do_test autovacuum-2.5.2.2 { |
| execsql { |
| SELECT * FROM av2 WHERE a = 'av2 a' AND b = 'av2 b' AND c = 'av2 c' |
| } |
| } {{av2 a} {av2 b} {av2 c}} |
| do_test autovacuum-2.5.2.3 { |
| execsql { |
| SELECT * FROM av3 WHERE a = 'av3 a' AND b = 'av3 b'; |
| } |
| } {{av3 a} {av3 b} {av3 c}} |
| do_test autovacuum-2.5.2.4 { |
| execsql { |
| SELECT * FROM av4 WHERE a = 'av4 a' AND b = 'av4 b' AND c = 'av4 c'; |
| } |
| } {{av4 a} {av4 b} {av4 c}} |
| |
| # Drop table av3. Indices av4_i2, av4_i3 and av4_i4 are moved to fill the two |
| # root pages vacated. The operation proceeds as: |
| # Step 1: Delete av3_i1 (root-page 11). Move root-page of av4_i4 to page 11. |
| # Step 2: Delete av3 (root-page 10). Move root-page of av4_i3 to page 10. |
| # Step 3: Delete sqlite_autoindex_av1_3 (root-page 9). Move av4_i2 to page 9. |
| do_test autovacuum-2.5.3 { |
| execsql { |
| DROP TABLE av3; |
| SELECT name, rootpage FROM sqlite_master; |
| } |
| } [list av1 3 sqlite_autoindex_av1_1 4 \ |
| av2 5 sqlite_autoindex_av2_1 6 av2_i1 7 av2_i2 8 \ |
| av4 12 av4_i1 13 av4_i2 9 av4_i3 10 av4_i4 11 \ |
| ] |
| do_test autovacuum-2.5.3.1 { |
| execsql { |
| SELECT * FROM av1 WHERE a = 'av1 a'; |
| } |
| } {{av1 a} {av1 b} {av1 c}} |
| do_test autovacuum-2.5.3.2 { |
| execsql { |
| SELECT * FROM av2 WHERE a = 'av2 a' AND b = 'av2 b' AND c = 'av2 c' |
| } |
| } {{av2 a} {av2 b} {av2 c}} |
| do_test autovacuum-2.5.3.3 { |
| execsql { |
| SELECT * FROM av4 WHERE a = 'av4 a' AND b = 'av4 b' AND c = 'av4 c'; |
| } |
| } {{av4 a} {av4 b} {av4 c}} |
| |
| # Drop table av1: |
| # Step 1: Delete av1 (root page 4). Root-page of av4_i1 fills the gap. |
| # Step 2: Delete sqlite_autoindex_av1_1 (root page 3). Move av4 to the gap. |
| do_test autovacuum-2.5.4 { |
| execsql { |
| DROP TABLE av1; |
| SELECT name, rootpage FROM sqlite_master; |
| } |
| } [list av2 5 sqlite_autoindex_av2_1 6 av2_i1 7 av2_i2 8 \ |
| av4 3 av4_i1 4 av4_i2 9 av4_i3 10 av4_i4 11 \ |
| ] |
| do_test autovacuum-2.5.4.2 { |
| execsql { |
| SELECT * FROM av2 WHERE a = 'av2 a' AND b = 'av2 b' AND c = 'av2 c' |
| } |
| } {{av2 a} {av2 b} {av2 c}} |
| do_test autovacuum-2.5.4.4 { |
| execsql { |
| SELECT * FROM av4 WHERE a = 'av4 a' AND b = 'av4 b' AND c = 'av4 c'; |
| } |
| } {{av4 a} {av4 b} {av4 c}} |
| |
| # Drop table av4: |
| # Step 1: Delete av4_i4. |
| # Step 2: Delete av4_i3. |
| # Step 3: Delete av4_i2. |
| # Step 4: Delete av4_i1. av2_i2 replaces it. |
| # Step 5: Delete av4. av2_i1 replaces it. |
| do_test autovacuum-2.5.5 { |
| execsql { |
| DROP TABLE av4; |
| SELECT name, rootpage FROM sqlite_master; |
| } |
| } [list av2 5 sqlite_autoindex_av2_1 6 av2_i1 3 av2_i2 4] |
| do_test autovacuum-2.5.5.2 { |
| execsql { |
| SELECT * FROM av2 WHERE a = 'av2 a' AND b = 'av2 b' AND c = 'av2 c' |
| } |
| } {{av2 a} {av2 b} {av2 c}} |
| |
| #-------------------------------------------------------------------------- |
| # Test cases autovacuum-3.* test the operation of the "PRAGMA auto_vacuum" |
| # command. |
| # |
| do_test autovacuum-3.1 { |
| execsql { |
| PRAGMA auto_vacuum; |
| } |
| } {1} |
| do_test autovacuum-3.2 { |
| db close |
| sqlite3 db test.db |
| execsql { |
| PRAGMA auto_vacuum; |
| } |
| } {1} |
| do_test autovacuum-3.3 { |
| execsql { |
| PRAGMA auto_vacuum = 0; |
| PRAGMA auto_vacuum; |
| } |
| } {1} |
| |
| do_test autovacuum-3.4 { |
| db close |
| file delete -force test.db |
| sqlite3 db test.db |
| execsql { |
| PRAGMA auto_vacuum; |
| } |
| } $AUTOVACUUM |
| do_test autovacuum-3.5 { |
| execsql { |
| CREATE TABLE av1(x); |
| PRAGMA auto_vacuum; |
| } |
| } $AUTOVACUUM |
| do_test autovacuum-3.6 { |
| execsql { |
| PRAGMA auto_vacuum = 1; |
| PRAGMA auto_vacuum; |
| } |
| } [expr $AUTOVACUUM ? 1 : 0] |
| do_test autovacuum-3.7 { |
| execsql { |
| DROP TABLE av1; |
| } |
| file_pages |
| } [expr $AUTOVACUUM?1:2] |
| |
| |
| #----------------------------------------------------------------------- |
| # Test that if a statement transaction around a CREATE INDEX statement is |
| # rolled back no corruption occurs. |
| # |
| do_test autovacuum-4.0 { |
| # The last round of tests may have left the db in non-autovacuum mode. |
| # Reset everything just in case. |
| # |
| db close |
| file delete -force test.db test.db-journal |
| sqlite3 db test.db |
| execsql { |
| PRAGMA auto_vacuum = 1; |
| PRAGMA auto_vacuum; |
| } |
| } {1} |
| do_test autovacuum-4.1 { |
| execsql { |
| CREATE TABLE av1(a, b); |
| BEGIN; |
| } |
| for {set i 0} {$i<100} {incr i} { |
| execsql "INSERT INTO av1 VALUES($i, '[string repeat X 200]');" |
| } |
| execsql "INSERT INTO av1 VALUES(99, '[string repeat X 200]');" |
| execsql { |
| SELECT sum(a) FROM av1; |
| } |
| } {5049} |
| do_test autovacuum-4.2 { |
| catchsql { |
| CREATE UNIQUE INDEX av1_i ON av1(a); |
| } |
| } {1 {indexed columns are not unique}} |
| do_test autovacuum-4.3 { |
| execsql { |
| SELECT sum(a) FROM av1; |
| } |
| } {5049} |
| do_test autovacuum-4.4 { |
| execsql { |
| COMMIT; |
| } |
| } {} |
| |
| ifcapable integrityck { |
| |
| # Ticket #1727 |
| do_test autovacuum-5.1 { |
| db close |
| sqlite3 db :memory: |
| db eval { |
| PRAGMA auto_vacuum=1; |
| CREATE TABLE t1(a); |
| CREATE TABLE t2(a); |
| DROP TABLE t1; |
| PRAGMA integrity_check; |
| } |
| } ok |
| |
| } |
| |
| # Ticket #1728. |
| # |
| # In autovacuum mode, when tables or indices are deleted, the rootpage |
| # values in the symbol table have to be updated. There was a bug in this |
| # logic so that if an index/table was moved twice, the second move might |
| # not occur. This would leave the internal symbol table in an inconsistent |
| # state causing subsequent statements to fail. |
| # |
| # The problem is difficult to reproduce. The sequence of statements in |
| # the following test are carefully designed make it occur and thus to |
| # verify that this very obscure bug has been resolved. |
| # |
| ifcapable integrityck&&memorydb { |
| |
| do_test autovacuum-6.1 { |
| db close |
| sqlite3 db :memory: |
| db eval { |
| PRAGMA auto_vacuum=1; |
| CREATE TABLE t1(a, b); |
| CREATE INDEX i1 ON t1(a); |
| CREATE TABLE t2(a); |
| CREATE INDEX i2 ON t2(a); |
| CREATE TABLE t3(a); |
| CREATE INDEX i3 ON t2(a); |
| CREATE INDEX x ON t1(b); |
| DROP TABLE t3; |
| PRAGMA integrity_check; |
| DROP TABLE t2; |
| PRAGMA integrity_check; |
| DROP TABLE t1; |
| PRAGMA integrity_check; |
| } |
| } {ok ok ok} |
| |
| } |
| |
| #--------------------------------------------------------------------- |
| # Test cases autovacuum-7.X test the case where a page must be moved |
| # and the destination location collides with at least one other |
| # entry in the page hash-table (internal to the pager.c module. |
| # |
| do_test autovacuum-7.1 { |
| db close |
| file delete -force test.db |
| file delete -force test.db-journal |
| sqlite3 db test.db |
| |
| execsql { |
| PRAGMA auto_vacuum=1; |
| CREATE TABLE t1(a, b, PRIMARY KEY(a, b)); |
| INSERT INTO t1 VALUES(randstr(400,400),randstr(400,400)); |
| INSERT INTO t1 SELECT randstr(400,400), randstr(400,400) FROM t1; -- 2 |
| INSERT INTO t1 SELECT randstr(400,400), randstr(400,400) FROM t1; -- 4 |
| INSERT INTO t1 SELECT randstr(400,400), randstr(400,400) FROM t1; -- 8 |
| INSERT INTO t1 SELECT randstr(400,400), randstr(400,400) FROM t1; -- 16 |
| INSERT INTO t1 SELECT randstr(400,400), randstr(400,400) FROM t1; -- 32 |
| } |
| |
| expr {[file size test.db] / 1024} |
| } {73} |
| |
| do_test autovacuum-7.2 { |
| execsql { |
| CREATE TABLE t2(a, b, PRIMARY KEY(a, b)); |
| INSERT INTO t2 SELECT randstr(400,400), randstr(400,400) FROM t1; -- 2 |
| CREATE TABLE t3(a, b, PRIMARY KEY(a, b)); |
| INSERT INTO t3 SELECT randstr(400,400), randstr(400,400) FROM t1; -- 2 |
| CREATE TABLE t4(a, b, PRIMARY KEY(a, b)); |
| INSERT INTO t4 SELECT randstr(400,400), randstr(400,400) FROM t1; -- 2 |
| CREATE TABLE t5(a, b, PRIMARY KEY(a, b)); |
| INSERT INTO t5 SELECT randstr(400,400), randstr(400,400) FROM t1; -- 2 |
| } |
| expr {[file size test.db] / 1024} |
| } {354} |
| |
| do_test autovacuum-7.3 { |
| db close |
| sqlite3 db test.db |
| execsql { |
| BEGIN; |
| DELETE FROM t4; |
| COMMIT; |
| SELECT count(*) FROM t1; |
| } |
| expr {[file size test.db] / 1024} |
| } {286} |
| |
| #------------------------------------------------------------------------ |
| # Additional tests. |
| # |
| # Try to determine the autovacuum setting for a database that is locked. |
| # |
| do_test autovacuum-8.1 { |
| db close |
| sqlite3 db test.db |
| sqlite3 db2 test.db |
| db eval {PRAGMA auto_vacuum} |
| } {1} |
| if {[permutation] == ""} { |
| do_test autovacuum-8.2 { |
| db eval {BEGIN EXCLUSIVE} |
| catchsql {PRAGMA auto_vacuum} db2 |
| } {1 {database is locked}} |
| catch {db2 close} |
| catch {db eval {COMMIT}} |
| } |
| |
| do_test autovacuum-9.1 { |
| execsql { |
| DROP TABLE t1; |
| DROP TABLE t2; |
| DROP TABLE t3; |
| DROP TABLE t4; |
| DROP TABLE t5; |
| PRAGMA page_count; |
| } |
| } {1} |
| do_test autovacuum-9.2 { |
| file size test.db |
| } 1024 |
| do_test autovacuum-9.3 { |
| execsql { |
| CREATE TABLE t1(a INTEGER PRIMARY KEY, b); |
| INSERT INTO t1 VALUES(NULL, randstr(50,50)); |
| } |
| for {set ii 0} {$ii < 10} {incr ii} { |
| db eval { INSERT INTO t1 SELECT NULL, randstr(50,50) FROM t1 } |
| } |
| file size test.db |
| } $::sqlite_pending_byte |
| do_test autovacuum-9.4 { |
| execsql { INSERT INTO t1 SELECT NULL, randstr(50,50) FROM t1 } |
| } {} |
| do_test autovacuum-9.5 { |
| execsql { DELETE FROM t1 WHERE rowid > (SELECT max(a)/2 FROM t1) } |
| file size test.db |
| } $::sqlite_pending_byte |
| |
| |
| finish_test |