Return to reindex.test CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test

Annotation of embedaddon/sqlite3/test/reindex.test, revision 1.1

1.1     ! misho       1: # 2004 November 5
        !             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 SQLite library.
        !            12: # This file implements tests for the REINDEX command.
        !            13: #
        !            14: # $Id: reindex.test,v 1.4 2008/07/12 14:52:20 drh Exp $
        !            15: 
        !            16: set testdir [file dirname $argv0]
        !            17: source $testdir/tester.tcl
        !            18: 
        !            19: # There is nothing to test if REINDEX is disable for this build.
        !            20: #
        !            21: ifcapable {!reindex} {
        !            22:   finish_test
        !            23:   return
        !            24: }
        !            25: 
        !            26: # Basic sanity checks.
        !            27: #
        !            28: do_test reindex-1.1 {
        !            29:   execsql {
        !            30:     CREATE TABLE t1(a,b);
        !            31:     INSERT INTO t1 VALUES(1,2);
        !            32:     INSERT INTO t1 VALUES(3,4);
        !            33:     CREATE INDEX i1 ON t1(a);
        !            34:     REINDEX;
        !            35:   }
        !            36: } {}
        !            37: integrity_check reindex-1.2
        !            38: do_test reindex-1.3 {
        !            39:   execsql {
        !            40:     REINDEX t1;
        !            41:   }
        !            42: } {}
        !            43: integrity_check reindex-1.4
        !            44: do_test reindex-1.5 {
        !            45:   execsql {
        !            46:     REINDEX i1;
        !            47:   }
        !            48: } {}
        !            49: integrity_check reindex-1.6
        !            50: do_test reindex-1.7 {
        !            51:   execsql {
        !            52:     REINDEX main.t1;
        !            53:   }
        !            54: } {}
        !            55: do_test reindex-1.8 {
        !            56:   execsql {
        !            57:     REINDEX main.i1;
        !            58:   }
        !            59: } {}
        !            60: do_test reindex-1.9 {
        !            61:   catchsql {
        !            62:     REINDEX bogus
        !            63:   }
        !            64: } {1 {unable to identify the object to be reindexed}}
        !            65: 
        !            66: # Set up a table for testing that includes several different collating
        !            67: # sequences including some that we can modify.
        !            68: #
        !            69: do_test reindex-2.1 {
        !            70:   proc c1 {a b} {
        !            71:     return [expr {-[string compare $a $b]}]
        !            72:   }
        !            73:   proc c2 {a b} {
        !            74:     return [expr {-[string compare [string tolower $a] [string tolower $b]]}]
        !            75:   }
        !            76:   db collate c1 c1
        !            77:   db collate c2 c2
        !            78:   execsql {
        !            79:     CREATE TABLE t2(
        !            80:       a TEXT PRIMARY KEY COLLATE c1,
        !            81:       b TEXT UNIQUE COLLATE c2,
        !            82:       c TEXT COLLATE nocase,
        !            83:       d TEST COLLATE binary
        !            84:     );
        !            85:     INSERT INTO t2 VALUES('abc','abc','abc','abc');
        !            86:     INSERT INTO t2 VALUES('ABCD','ABCD','ABCD','ABCD');
        !            87:     INSERT INTO t2 VALUES('bcd','bcd','bcd','bcd');
        !            88:     INSERT INTO t2 VALUES('BCDE','BCDE','BCDE','BCDE');
        !            89:     SELECT a FROM t2 ORDER BY a;
        !            90:   }
        !            91: } {bcd abc BCDE ABCD}
        !            92: do_test reindex-2.2 {
        !            93:   execsql {
        !            94:     SELECT b FROM t2 ORDER BY b;
        !            95:   }
        !            96: } {BCDE bcd ABCD abc}
        !            97: do_test reindex-2.3 {
        !            98:   execsql {
        !            99:     SELECT c FROM t2 ORDER BY c;
        !           100:   }
        !           101: } {abc ABCD bcd BCDE}
        !           102: do_test reindex-2.4 {
        !           103:   execsql {
        !           104:     SELECT d FROM t2 ORDER BY d;
        !           105:   }
        !           106: } {ABCD BCDE abc bcd}
        !           107: 
        !           108: # Change a collating sequence function.  Verify that REINDEX rebuilds
        !           109: # the index.
        !           110: #
        !           111: do_test reindex-2.5 {
        !           112:   proc c1 {a b} {
        !           113:     return [string compare $a $b]
        !           114:   }
        !           115:   execsql {
        !           116:     SELECT a FROM t2 ORDER BY a;
        !           117:   }
        !           118: } {bcd abc BCDE ABCD}
        !           119: ifcapable {integrityck} {
        !           120:   do_test reindex-2.5.1 {
        !           121:     string equal ok [execsql {PRAGMA integrity_check}]
        !           122:   } {0}
        !           123: }
        !           124: do_test reindex-2.6 {
        !           125:   execsql {
        !           126:     REINDEX c2;
        !           127:     SELECT a FROM t2 ORDER BY a;
        !           128:   }
        !           129: } {bcd abc BCDE ABCD}
        !           130: do_test reindex-2.7 {
        !           131:   execsql {
        !           132:     REINDEX t1;
        !           133:     SELECT a FROM t2 ORDER BY a;
        !           134:   }
        !           135: } {bcd abc BCDE ABCD}
        !           136: do_test reindex-2.8 {
        !           137:   execsql {
        !           138:     REINDEX c1;
        !           139:     SELECT a FROM t2 ORDER BY a;
        !           140:   }
        !           141: } {ABCD BCDE abc bcd}
        !           142: integrity_check reindex-2.8.1
        !           143: 
        !           144: # Try to REINDEX an index for which the collation sequence is not available.
        !           145: #
        !           146: do_test reindex-3.1 {
        !           147:   sqlite3 db2 test.db
        !           148:   catchsql {
        !           149:     REINDEX c1;
        !           150:   } db2
        !           151: } {1 {no such collation sequence: c1}}
        !           152: do_test reindex-3.2 {
        !           153:   proc need_collate {collation} {
        !           154:     db2 collate c1 c1
        !           155:   }
        !           156:   db2 collation_needed need_collate
        !           157:   catchsql {
        !           158:     REINDEX c1;
        !           159:   } db2
        !           160: } {0 {}}
        !           161: do_test reindex-3.3 {
        !           162:   catchsql {
        !           163:     REINDEX;
        !           164:   } db2
        !           165: } {1 {no such collation sequence: c2}}
        !           166: 
        !           167: do_test reindex-3.99 {
        !           168:   db2 close
        !           169: } {}
        !           170: 
        !           171: finish_test