/ Check-in [5d95b429]
Login

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Pull the latest trunk changes into the sessions branch.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | sessions
Files: files | file ages | folders
SHA1: 5d95b42946b5cf0346164aebe0a8c4f37527bc31
User & Date: drh 2011-06-23 02:11:11
Context
2011-06-23
17:40
Pull the latest version 3.7.7 release-candidate changes into the sessions branch. check-in: 840bf9c2 user: drh tags: sessions
02:11
Pull the latest trunk changes into the sessions branch. check-in: 5d95b429 user: drh tags: sessions
01:42
Provide the SQLITE_MAX_SCHEMA_RETRY compile-time parameter for adjusting the number of reparse attempts after a schema change. check-in: 8dca748b user: drh tags: trunk
2011-06-22
12:01
Update sessions branch with latest trunk changes. check-in: 48d5cab3 user: dan tags: sessions
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to ext/fts3/fts3.c.

   640    640         rc = SQLITE_NOMEM;
   641    641       }else{
   642    642         rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
   643    643         if( rc==SQLITE_OK ){
   644    644           sqlite3_step(pStmt);
   645    645           p->nPgsz = sqlite3_column_int(pStmt, 0);
   646    646           rc = sqlite3_finalize(pStmt);
          647  +      }else if( rc==SQLITE_AUTH ){
          648  +        p->nPgsz = 1024;
          649  +        rc = SQLITE_OK;
   647    650         }
   648    651       }
   649    652       assert( p->nPgsz>0 || rc!=SQLITE_OK );
   650    653       sqlite3_free(zSql);
   651    654       *pRc = rc;
   652    655     }
   653    656   }

Changes to src/test1.c.

  5513   5513   
  5514   5514     if( objc!=2 ){
  5515   5515       Tcl_WrongNumArgs(interp, 1, objv, "STMT");
  5516   5516       return TCL_ERROR;
  5517   5517     }
  5518   5518     if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
  5519   5519     rc = printExplainQueryPlan(pStmt);
         5520  +  /* This is needed on Windows so that a test case using this 
         5521  +  ** function can open a read pipe and get the output of
         5522  +  ** printExplainQueryPlan() immediately.
         5523  +  */
         5524  +  fflush(stdout);
  5520   5525     Tcl_SetResult(interp, (char *)t1ErrorName(rc), 0);
  5521   5526     return TCL_OK;
  5522   5527   }
  5523   5528   #endif /* SQLITE_OMIT_EXPLAIN */
  5524   5529   
  5525   5530   /*
  5526   5531   ** sqlite3_test_control VERB ARGS...

Changes to src/test_vfs.c.

  1066   1066         break;
  1067   1067       }
  1068   1068   
  1069   1069       case CMD_SCRIPT: {
  1070   1070         if( objc==3 ){
  1071   1071           int nByte;
  1072   1072           if( p->pScript ){
  1073         -          int i;
  1074   1073             Tcl_DecrRefCount(p->pScript);
  1075   1074             p->pScript = 0;
  1076   1075           }
  1077   1076           Tcl_GetStringFromObj(objv[2], &nByte);
  1078   1077           if( nByte>0 ){
  1079   1078             p->pScript = Tcl_DuplicateObj(objv[2]);
  1080   1079             Tcl_IncrRefCount(p->pScript);
................................................................................
  1219   1218     }
  1220   1219   
  1221   1220     return TCL_OK;
  1222   1221   }
  1223   1222   
  1224   1223   static void testvfs_obj_del(ClientData cd){
  1225   1224     Testvfs *p = (Testvfs *)cd;
  1226         -  int i;
  1227   1225     if( p->pScript ) Tcl_DecrRefCount(p->pScript);
  1228   1226     sqlite3_vfs_unregister(p->pVfs);
  1229   1227     ckfree((char *)p->pVfs);
  1230   1228     ckfree((char *)p);
  1231   1229   }
  1232   1230   
  1233   1231   /*

Changes to src/vdbeapi.c.

   455    455       ** caller. Set the error code in the database handle to the same value.
   456    456       */ 
   457    457       rc = db->errCode = p->rc;
   458    458     }
   459    459     return (rc&db->errMask);
   460    460   }
   461    461   
          462  +/*
          463  +** The maximum number of times that a statement will try to reparse
          464  +** itself before giving up and returning SQLITE_SCHEMA.
          465  +*/
          466  +#ifndef SQLITE_MAX_SCHEMA_RETRY
          467  +# define SQLITE_MAX_SCHEMA_RETRY 5
          468  +#endif
          469  +
   462    470   /*
   463    471   ** This is the top-level implementation of sqlite3_step().  Call
   464    472   ** sqlite3Step() to do most of the work.  If a schema error occurs,
   465    473   ** call sqlite3Reprepare() and try again.
   466    474   */
   467    475   int sqlite3_step(sqlite3_stmt *pStmt){
   468    476     int rc = SQLITE_OK;      /* Result from sqlite3Step() */
................................................................................
   473    481   
   474    482     if( vdbeSafetyNotNull(v) ){
   475    483       return SQLITE_MISUSE_BKPT;
   476    484     }
   477    485     db = v->db;
   478    486     sqlite3_mutex_enter(db->mutex);
   479    487     while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
   480         -         && cnt++ < 5
          488  +         && cnt++ < SQLITE_MAX_SCHEMA_RETRY
   481    489            && (rc2 = rc = sqlite3Reprepare(v))==SQLITE_OK ){
   482    490       sqlite3_reset(pStmt);
   483    491       v->expired = 0;
   484    492     }
   485    493     if( rc2!=SQLITE_OK && ALWAYS(v->isPrepareV2) && ALWAYS(db->pErr) ){
   486    494       /* This case occurs after failing to recompile an sql statement. 
   487    495       ** The error message from the SQL compiler has already been loaded 

Changes to test/fts4aa.test.

    18     18   
    19     19   # If SQLITE_ENABLE_FTS3 is defined, omit this file.
    20     20   ifcapable !fts3 {
    21     21     finish_test
    22     22     return
    23     23   }
    24     24   
    25         -do_test fts4aa-1.0 {
           25  +# This procedure fills an existing FTS3/FTS4 table with many entries.
           26  +# The table needs to have a single column (other than docid) named "words".
           27  +#
           28  +proc fts4aa_fill_table {} {
    26     29   db eval {
    27         -CREATE VIRTUAL TABLE t1 USING fts4(words, tokenize porter);
    28     30   BEGIN TRANSACTION;
    29     31   INSERT INTO t1(docid,words) VALUES(1001001,'In the beginning God created the heaven and the earth.');
    30     32   INSERT INTO t1(docid,words) VALUES(1001002,'And the earth was without form, and void; and darkness was upon the face of the deep. And the Spirit of God moved upon the face of the waters.');
    31     33   INSERT INTO t1(docid,words) VALUES(1001003,'And God said, Let there be light: and there was light.');
    32     34   INSERT INTO t1(docid,words) VALUES(1001004,'And God saw the light, that it was good: and God divided the light from the darkness.');
    33     35   INSERT INTO t1(docid,words) VALUES(1001005,'And God called the light Day, and the darkness he called Night. And the evening and the morning were the first day.');
    34     36   INSERT INTO t1(docid,words) VALUES(1001006,'And God said, Let there be a firmament in the midst of the waters, and let it divide the waters from the waters.');
................................................................................
  1557   1559   INSERT INTO t1(docid,words) VALUES(1050022,'And Joseph dwelt in Egypt, he, and his father''s house: and Joseph lived an hundred and ten years.');
  1558   1560   INSERT INTO t1(docid,words) VALUES(1050023,'And Joseph saw Ephraim''s children of the third generation: the children also of Machir the son of Manasseh were brought up upon Joseph''s knees.');
  1559   1561   INSERT INTO t1(docid,words) VALUES(1050024,'And Joseph said unto his brethren, I die: and God will surely visit you, and bring you out of this land unto the land which he sware to Abraham, to Isaac, and to Jacob.');
  1560   1562   INSERT INTO t1(docid,words) VALUES(1050025,'And Joseph took an oath of the children of Israel, saying, God will surely visit you, and ye shall carry up my bones from hence.');
  1561   1563   INSERT INTO t1(docid,words) VALUES(1050026,'So Joseph died, being an hundred and ten years old: and they embalmed him, and he was put in a coffin in Egypt.');
  1562   1564   COMMIT;
  1563   1565   }
         1566  +}
         1567  +
         1568  +# The following is a list of queries to perform against the above
         1569  +# FTS3/FTS4 database.  We will be trying these queries in various
         1570  +# configurations to ensure that they always return the same answers.
         1571  +#
         1572  +set fts4aa_queries {
         1573  +  {abraham}
         1574  +  {the king}
         1575  +  {"the king"}
         1576  +  {abraham OR joseph}
         1577  +  {ab* OR jos*}
         1578  +  {lived t*}
         1579  +  {spake hebrew}
         1580  +  {melchizedek}
         1581  +  {t* melchizedek}
         1582  +  {melchizedek t*}
         1583  +}
         1584  +unset -nocomplain fts4aa_res
         1585  +
         1586  +# Set up the baseline results
         1587  +#
         1588  +do_test fts4aa-1.0 {
         1589  +  db eval {
         1590  +    CREATE VIRTUAL TABLE t1 USING fts4(words, tokenize porter);
         1591  +  }
         1592  +  fts4aa_fill_table
         1593  +  foreach q $::fts4aa_queries {
         1594  +    set r [db eval {SELECT docid FROM t1 WHERE words MATCH $q ORDER BY docid}]
         1595  +    set ::fts4aa_res($q) $r
         1596  +  }
  1564   1597   } {}
  1565   1598   
  1566         -
         1599  +# Legacy test cases
         1600  +#
  1567   1601   do_test fts4aa-1.1 {
  1568   1602     db eval {
  1569   1603       SELECT docid FROM t1 EXCEPT SELECT docid FROM t1_docsize
  1570   1604     }
  1571   1605   } {}
  1572   1606   do_test fts4aa-1.2 {
  1573   1607     db eval {
................................................................................
  1579   1613     set scan(littleEndian) i*
  1580   1614     set scan(bigEndian) I*
  1581   1615     binary scan $blob $scan($::tcl_platform(byteOrder)) r
  1582   1616     return $r
  1583   1617   }
  1584   1618   db func mit mit
  1585   1619   
  1586         -do_test fts4aa-2.1 {
         1620  +do_test fts4aa-1.3 {
  1587   1621     db eval {
  1588   1622       SELECT docid, mit(matchinfo(t1, 'pcxnal')) FROM t1 WHERE t1 MATCH 'melchizedek';
  1589   1623     }
  1590   1624   } {1014018 {1 1 1 1 1 1533 25 20}}
  1591         -do_test fts4aa-2.2 {
         1625  +do_test fts4aa-1.4 {
  1592   1626     db eval {
  1593   1627       SELECT docid, mit(matchinfo(t1, 'pcxnal')) FROM t1
  1594   1628        WHERE t1 MATCH 'spake hebrew'
  1595   1629        ORDER BY docid;
  1596   1630     }
  1597   1631   } {1039014 {2 1 1 40 40 1 6 6 1533 25 42} 1039017 {2 1 1 40 40 1 6 6 1533 25 26}}
  1598         -do_test fts4aa-2.3 {
         1632  +do_test fts4aa-1.5 {
  1599   1633     db eval {
  1600   1634       SELECT docid, mit(matchinfo(t1, 'pcxnal')) FROM t1
  1601   1635        WHERE t1 MATCH 'laban overtook jacob'
  1602   1636        ORDER BY docid;
  1603   1637     }
  1604   1638   } {1031025 {3 1 2 54 46 1 3 3 2 181 160 1533 25 24}}
  1605   1639   
  1606         -do_test fts4aa-9.1 {
         1640  +do_test fts4aa-1.6 {
  1607   1641     db eval {
  1608   1642       DELETE FROM t1 WHERE docid!=1050026;
  1609   1643       SELECT hex(size) FROM t1_docsize;
  1610   1644       SELECT hex(value) FROM t1_stat;
  1611   1645     }
  1612   1646   } {17 01176F}
  1613   1647   
  1614         -do_test fts4aa-9.2 {
         1648  +do_test fts4aa-1.7 {
  1615   1649     db eval {
  1616   1650       SELECT docid FROM t1 EXCEPT SELECT docid FROM t1_docsize
  1617   1651     }
  1618   1652   } {}
  1619         -do_test fts4aa-9.3 {
         1653  +do_test fts4aa-1.8 {
  1620   1654     db eval {
  1621   1655       SELECT docid FROM t1_docsize EXCEPT SELECT docid FROM t1
  1622   1656     }
  1623   1657   } {}
  1624         -do_test fts4aa-9.4 {
         1658  +do_test fts4aa-1.9 {
  1625   1659     # Note: Token 'in' is being deferred in the following query. 
  1626   1660     db eval {
  1627   1661       SELECT docid, mit(matchinfo(t1, 'pcxnal')) FROM t1
  1628   1662        WHERE t1 MATCH 'joseph died in egypt'
  1629   1663        ORDER BY docid;
  1630   1664     }
  1631   1665   } {1050026 {4 1 1 1 1 1 1 1 2 1 1 1 1 1 1 23 23}}
         1666  +
         1667  +# Should get the same search results from FTS3
         1668  +#
         1669  +do_test fts4aa-2.0 {
         1670  +  db eval {
         1671  +    DROP TABLE t1;
         1672  +    CREATE VIRTUAL TABLE t1 USING fts3(words, tokenize porter);
         1673  +  }
         1674  +  fts4aa_fill_table
         1675  +} {}
         1676  +unset -nocomplain ii
         1677  +set ii 0
         1678  +foreach {q r} [array get fts4aa_res] {
         1679  +  incr ii
         1680  +  do_test fts4aa-2.$ii {
         1681  +    db eval {SELECT docid FROM t1 WHERE words MATCH $::q ORDER BY docid}
         1682  +  } $r
         1683  +}
         1684  +
         1685  +# Should get the same search results when the page size is very large
         1686  +#
         1687  +do_test fts4aa-3.0 {
         1688  +  db close
         1689  +  file delete -force test.db
         1690  +  sqlite3 db test.db
         1691  +  db eval {
         1692  +    PRAGMA page_size=65536;
         1693  +    CREATE VIRTUAL TABLE t1 USING fts4(words, tokenize porter);
         1694  +  }
         1695  +  fts4aa_fill_table
         1696  +} {}
         1697  +unset -nocomplain ii
         1698  +set ii 0
         1699  +foreach {q r} [array get fts4aa_res] {
         1700  +  incr ii
         1701  +  do_test fts4aa-3.$ii {
         1702  +    db eval {SELECT docid FROM t1 WHERE words MATCH $::q ORDER BY docid}
         1703  +  } $r
         1704  +}
         1705  +
         1706  +# Should get the same search results when an authorizer prevents
         1707  +# all PRAGMA statements.
         1708  +#
         1709  +proc no_pragma_auth {code arg1 arg2 arg3 arg4} {
         1710  +  if {$code=="SQLITE_PRAGMA"} {return SQLITE_DENY}
         1711  +  return SQLITE_OK;
         1712  +}
         1713  +do_test fts4aa-4.0 {
         1714  +  db auth ::no_pragma_auth
         1715  +  db eval {
         1716  +    DROP TABLE t1;
         1717  +    CREATE VIRTUAL TABLE t1 USING fts4(words, tokenize porter);
         1718  +  }
         1719  +  fts4aa_fill_table
         1720  +} {}
         1721  +unset -nocomplain ii
         1722  +set ii 0
         1723  +foreach {q r} [array get fts4aa_res] {
         1724  +  incr ii
         1725  +  do_test fts4aa-4.$ii {
         1726  +    db eval {SELECT docid FROM t1 WHERE words MATCH $::q ORDER BY docid}
         1727  +  } $r
         1728  +}
  1632   1729   
  1633   1730   finish_test

Changes to test/oserror.test.

    47     47   # Test a failure in open() due to too many files. 
    48     48   #
    49     49   # The xOpen() method of the unix VFS calls getcwd() as well as open().
    50     50   # Although this does not appear to be documented in the man page, on OSX
    51     51   # a call to getcwd() may fail if there are no free file descriptors. So
    52     52   # an error may be reported for either open() or getcwd() here.
    53     53   #
           54  +puts "Possible valgrind error about invalid file descriptor follows:"
    54     55   do_test 1.1.1 {
    55     56     set ::log [list]
    56     57     list [catch {
    57     58       for {set i 0} {$i < 2000} {incr i} { sqlite3 dbh_$i test.db -readonly 1 }
    58     59     } msg] $msg
    59     60   } {1 {unable to open database file}}
    60     61   do_test 1.1.2 {

Changes to test/triggerC.test.

   224    224         INSERT INTO t2 VALUES(10);
   225    225         SELECT * FROM t2;
   226    226       }
   227    227     } $rc
   228    228   }
   229    229   
   230    230   do_test triggerC-2.2 {
   231         -  execsql {
          231  +  execsql "
   232    232       CREATE TABLE t22(x);
   233    233   
   234    234       CREATE TRIGGER t22a AFTER INSERT ON t22 BEGIN
   235    235         INSERT INTO t22 SELECT x + (SELECT max(x) FROM t22) FROM t22;
   236    236       END;
   237    237       CREATE TRIGGER t22b BEFORE INSERT ON t22 BEGIN
   238         -      SELECT CASE WHEN (SELECT count(*) FROM t22) >= 100
          238  +      SELECT CASE WHEN (SELECT count(*) FROM t22) >= [expr $SQLITE_MAX_TRIGGER_DEPTH / 2]
   239    239                     THEN RAISE(IGNORE)
   240    240                     ELSE NULL END;
   241    241       END;
   242    242   
   243    243       INSERT INTO t22 VALUES(1);
   244    244       SELECT count(*) FROM t22;
   245         -  }
   246         -} {100}
          245  +  "
          246  +} [list [expr $SQLITE_MAX_TRIGGER_DEPTH / 2]]
   247    247   
   248    248   do_test triggerC-2.3 {
   249    249     execsql "
   250    250       CREATE TABLE t23(x PRIMARY KEY);
   251    251   
   252    252       CREATE TRIGGER t23a AFTER INSERT ON t23 BEGIN
   253    253         INSERT INTO t23 VALUES(new.x + 1);

Changes to test/wal5.test.

   231    231       } {}
   232    232       do_test 2.3.$tn.2 { file_page_counts } {1 5 1 5}
   233    233       do_test 2.3.$tn.3 { sql2 { BEGIN; SELECT * FROM t1 } } {1 2}
   234    234       do_test 2.3.$tn.4 { sql1 { INSERT INTO t1 VALUES(3, 4) } } {}
   235    235       do_test 2.3.$tn.5 { sql1 { INSERT INTO t2 VALUES(3, 4) } } {}
   236    236       do_test 2.3.$tn.6 { file_page_counts } {1 7 1 7}
   237    237       do_test 2.3.$tn.7 { code1 { do_wal_checkpoint db -mode full } } {1 7 5}
   238         -    do_test 2.3.$tn.8 { file_page_counts } {1 7 2 7}
          238  +    if {$tcl_platform(platform) == "windows"} {
          239  +        # on unix, the size_hint is a no-op if no chunk size is set.
          240  +        # the windows implementation does not have a similar check,
          241  +        # and because of this, the db file size has an extra page.
          242  +        do_test 2.3.$tn.8 { file_page_counts } {2 7 2 7}
          243  +    } {
          244  +        do_test 2.3.$tn.8 { file_page_counts } {1 7 2 7}
          245  +    }
   239    246     }
   240    247   
   241    248     # Check that checkpoints block on the correct locks. And respond correctly
   242    249     # if they cannot obtain those locks. There are three locks that a checkpoint
   243    250     # may block on (in the following order):
   244    251     #
   245    252     #   1. The writer lock: FULL and RESTART checkpoints block until any writer

Changes to tool/omittest.tcl.

    27     27     * The makefile should support the "testfixture" target.
    28     28     * The makefile should support the "test" target.
    29     29     * The makefile should support the variable "OPTS" as a way to pass
    30     30       options from the make command line to lemon and the C compiler.
    31     31   
    32     32   More precisely, the following two invocations must be supported:
    33     33   
    34         -  make -f $::MAKEFILE testfixture OPTS="-DSQLITE_OMIT_ALTERTABLE=1"
    35         -  make -f $::MAKEFILE test
           34  +  $::MAKEBIN -f $::MAKEFILE testfixture OPTS="-DSQLITE_OMIT_ALTERTABLE=1"
           35  +  $::MAKEBIN -f $::MAKEFILE test
    36     36   
    37     37   Makefiles generated by the sqlite configure program cannot be used as
    38     38   they do not respect the OPTS variable.
    39     39   }
    40     40   
    41     41   
    42     42   # Build a testfixture executable and run quick.test using it. The first
................................................................................
    69     69     puts -nonewline "Building $dir..."
    70     70     flush stdout
    71     71   catch {
    72     72     file copy -force ./config.h $dir
    73     73     file copy -force ./libtool $dir
    74     74   }
    75     75     set rc [catch {
    76         -    exec make -C $dir -f $::MAKEFILE $target OPTS=$opts >& $dir/build.log
           76  +    exec $::MAKEBIN -C $dir -f $::MAKEFILE clean $target OPTS=$opts >& $dir/build.log
    77     77     }]
    78     78     if {$rc} {
    79     79       puts "No good. See $dir/build.log."
    80     80       return
    81     81     } else {
    82     82       puts "Ok"
    83     83     }
................................................................................
    98     98     if {$::SKIP_RUN} {
    99     99         puts "Skip testing $dir."
   100    100     } else {
   101    101       # Run the test suite.
   102    102       puts -nonewline "Testing $dir..."
   103    103       flush stdout
   104    104       set rc [catch {
   105         -      exec make -C $dir -f $::MAKEFILE test OPTS=$opts >& $dir/test.log
          105  +      exec $::MAKEBIN -C $dir -f $::MAKEFILE test OPTS=$opts >& $dir/test.log
   106    106       }]
   107    107       if {$rc} {
   108    108         puts "No good. See $dir/test.log."
   109    109       } else {
   110    110         puts "Ok"
   111    111       }
   112    112     }
................................................................................
   115    115   
   116    116   # This proc processes the command line options passed to this script.
   117    117   # Currently the only option supported is "-makefile", default
   118    118   # "../Makefile.linux-gcc". Set the ::MAKEFILE variable to the value of this
   119    119   # option.
   120    120   #
   121    121   proc process_options {argv} {
          122  +  set ::MAKEBIN make                        ;# Default value
   122    123     if {$::tcl_platform(platform)=="windows" || $::tcl_platform(platform)=="os2"} {
   123         -    set ::MAKEFILE ./Makefile               ;# Default value
          124  +    set ::MAKEFILE ./Makefile               ;# Default value on Windows and OS2
   124    125     } else {
   125    126       set ::MAKEFILE ./Makefile.linux-gcc     ;# Default value
   126    127     }
   127    128     set ::SKIP_RUN 0                          ;# Default to attempt test
   128    129   
   129    130     for {set i 0} {$i < [llength $argv]} {incr i} {
   130    131       switch -- [lindex $argv $i] {
   131    132         -makefile {
   132    133           incr i
   133    134           set ::MAKEFILE [lindex $argv $i]
   134    135         }
   135    136     
          137  +      -nmake {
          138  +        set ::MAKEBIN nmake
          139  +        set ::MAKEFILE ./Makefile.msc
          140  +      }
          141  +
   136    142         -skip_run {
   137    143           set ::SKIP_RUN 1
   138    144         }
   139    145   
   140    146         default {
   141    147           if {[info exists ::SYMBOL]} {
   142    148             puts stderr [string trim $::USAGE_MESSAGE]
................................................................................
   247    253       set sym $::SYMBOL
   248    254   
   249    255       if {[lsearch $::OMIT_SYMBOLS $sym]<0 && [lsearch $::ENABLE_SYMBOLS $sym]<0} {
   250    256         puts stderr "No such symbol: $sym"
   251    257         exit -1
   252    258       }
   253    259   
   254         -    set dirname "test_[string range $sym 7 end]"
          260  +    set dirname "test_[regsub -nocase {^x*SQLITE_} $sym {}]"
   255    261       run_quick_test $dirname $sym
   256    262     } else {
   257    263       # First try a test with all OMIT symbols except SQLITE_OMIT_FLOATING_POINT 
   258    264       # and SQLITE_OMIT_PRAGMA defined. The former doesn't work (causes segfaults)
   259    265       # and the latter is currently incompatible with the test suite (this should
   260    266       # be fixed, but it will be a lot of work).
   261    267       set allsyms [list]
................................................................................
   266    272       }
   267    273       run_quick_test test_OMIT_EVERYTHING $allsyms
   268    274     
   269    275       # Now try one quick.test with each of the OMIT symbols defined. Included
   270    276       # are the OMIT_FLOATING_POINT and OMIT_PRAGMA symbols, even though we
   271    277       # know they will fail. It's good to be reminded of this from time to time.
   272    278       foreach sym $::OMIT_SYMBOLS {
   273         -      set dirname "test_[string range $sym 7 end]"
          279  +      set dirname "test_[regsub -nocase {^x*SQLITE_} $sym {}]"
   274    280         run_quick_test $dirname $sym
   275    281       }
   276    282     
   277    283       # Try the ENABLE/DISABLE symbols one at a time.  
   278    284       # We don't do them all at once since some are conflicting.
   279    285       foreach sym $::ENABLE_SYMBOLS {
   280         -      set dirname "test_[string range $sym 7 end]"
          286  +      set dirname "test_[regsub -nocase {^x*SQLITE_} $sym {}]"
   281    287         run_quick_test $dirname $sym
   282    288       }
   283    289     }
   284    290   }
   285    291   
   286    292   main $argv