/ Check-in [60fed5cd]
Login

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

Overview
Comment:Merge latest trunk changes with this branch.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | rowvalue
Files: files | file ages | folders
SHA1: 60fed5cdd4a44aefa1b4d505adeb7936f2f0b952
User & Date: dan 2016-07-22 17:58:05
Context
2016-07-23
20:24
Allow vector IN(SELECT ...) expressions to use an index if either all the indexed columns are declared NOT NULL or if there is no difference between the expression evaluating to 0 and NULL (as in a WHERE clause). check-in: e2fd6f49 user: dan tags: rowvalue
2016-07-22
17:58
Merge latest trunk changes with this branch. check-in: 60fed5cd user: dan tags: rowvalue
10:09
Fix a problem with upper case module names in the "sqldiff --vtab" command. check-in: 87e25fc4 user: dan tags: trunk
2016-07-13
19:48
Modifications towards better vector IN(...) support on this branch. Not activated yet. check-in: 34e35c71 user: dan tags: rowvalue
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to ext/fts5/fts5_storage.c.

   243    243     int bWithout,                   /* True for without rowid */
   244    244     char **pzErr                    /* OUT: Error message */
   245    245   ){
   246    246     int rc;
   247    247     char *zErr = 0;
   248    248   
   249    249     rc = fts5ExecPrintf(pConfig->db, &zErr, "CREATE TABLE %Q.'%q_%q'(%s)%s",
   250         -      pConfig->zDb, pConfig->zName, zPost, zDefn, bWithout?" WITHOUT ROWID":""
          250  +      pConfig->zDb, pConfig->zName, zPost, zDefn, 
          251  +#ifndef SQLITE_FTS5_NO_WITHOUT_ROWID
          252  +      bWithout?" WITHOUT ROWID":
          253  +#endif
          254  +      ""
   251    255     );
   252    256     if( zErr ){
   253    257       *pzErr = sqlite3_mprintf(
   254    258           "fts5: error creating shadow table %q_%s: %s", 
   255    259           pConfig->zName, zPost, zErr
   256    260       );
   257    261       sqlite3_free(zErr);

Changes to ext/fts5/test/fts5rank.test.

    96     96   #
    97     97   #   ... MATCH 'x OR y' ORDER BY rank;
    98     98   #
    99     99   # if there were zero occurrences of token 'y' in the dataset. The
   100    100   # following tests verify that that problem has been addressed.
   101    101   #
   102    102   foreach_detail_mode $::testprefix {
   103         -  do_execsql_test 3.0 {
          103  +  do_execsql_test 3.1.0 {
   104    104       CREATE VIRTUAL TABLE y1 USING fts5(z, detail=%DETAIL%);
   105    105       INSERT INTO y1 VALUES('test xyz');
   106    106       INSERT INTO y1 VALUES('test test xyz test');
   107    107       INSERT INTO y1 VALUES('test test xyz');
   108    108     }
   109    109   
   110         -  do_execsql_test 3.1 {
          110  +  do_execsql_test 3.1.1 {
   111    111       SELECT rowid FROM y1('test OR tset');
   112    112     } {1 2 3}
   113    113   
   114         -  do_execsql_test 3.2 {
          114  +  do_execsql_test 3.1.2 {
   115    115       SELECT rowid FROM y1('test OR tset') ORDER BY bm25(y1)
   116    116     } {2 3 1}
   117    117   
   118         -  do_execsql_test 3.3 {
          118  +  do_execsql_test 3.1.3 {
   119    119       SELECT rowid FROM y1('test OR tset') ORDER BY +rank
   120    120     } {2 3 1}
   121    121   
   122         -  do_execsql_test 3.4 {
          122  +  do_execsql_test 3.1.4 {
   123    123       SELECT rowid FROM y1('test OR tset') ORDER BY rank
   124    124     } {2 3 1}
          125  +
          126  +  do_execsql_test 3.1.5 {
          127  +    SELECT rowid FROM y1('test OR xyz') ORDER BY rank
          128  +  } {3 2 1}
          129  +
          130  +
          131  +  do_execsql_test 3.2.1 {
          132  +    CREATE VIRTUAL TABLE z1 USING fts5(a, detail=%DETAIL%);
          133  +    INSERT INTO z1 VALUES('wrinkle in time');
          134  +    SELECT * FROM z1 WHERE z1 MATCH 'wrinkle in time OR a wrinkle in time';
          135  +  } {{wrinkle in time}}
   125    136   }
          137  +
          138  +do_execsql_test 4.1 {
          139  +  DROP TABLE IF EXISTS VTest;
          140  +  CREATE virtual TABLE VTest USING FTS5(
          141  +    Title, AUthor, tokenize ='porter unicode61 remove_diacritics 1', 
          142  +    columnsize='1', detail=full
          143  +  );
          144  +  INSERT INTO VTest (Title, Author) VALUES ('wrinkle in time', 'Bill Smith');
          145  +
          146  +  SELECT * FROM VTest WHERE 
          147  +  VTest MATCH 'wrinkle in time OR a wrinkle in time' ORDER BY rank;
          148  +} {{wrinkle in time} {Bill Smith}}
          149  +
          150  +
   126    151   
   127    152   
   128    153   finish_test
   129    154   

Changes to ext/misc/carray.c.

    10     10   **
    11     11   *************************************************************************
    12     12   **
    13     13   ** This file demonstrates how to create a table-valued-function that
    14     14   ** returns the values in a C-language array.
    15     15   ** Examples:
    16     16   **
    17         -**      SELECT * FROM array($ptr,5)
           17  +**      SELECT * FROM carray($ptr,5)
    18     18   **
    19     19   ** The query above returns 5 integers contained in a C-language array
    20     20   ** at the address $ptr.  $ptr is a pointer to the array of integers that
    21     21   ** has been cast to an integer.
    22     22   **
    23     23   ** There is an optional third parameter to determine the datatype of
    24     24   ** the C-language array.  Allowed values of the third parameter are
    25     25   ** 'int32', 'int64', 'double', 'char*'.  Example:
    26     26   **
    27         -**      SELECT * FROM array($ptr,10,'char*');
           27  +**      SELECT * FROM carray($ptr,10,'char*');
    28     28   **
    29     29   ** HOW IT WORKS
    30     30   **
    31     31   ** The carray "function" is really a virtual table with the
    32     32   ** following schema:
    33     33   **
    34     34   **     CREATE TABLE carray(
................................................................................
   354    354     sqlite3 *db, 
   355    355     char **pzErrMsg, 
   356    356     const sqlite3_api_routines *pApi
   357    357   ){
   358    358     int rc = SQLITE_OK;
   359    359     SQLITE_EXTENSION_INIT2(pApi);
   360    360   #ifndef SQLITE_OMIT_VIRTUALTABLE
   361         -  if( sqlite3_libversion_number()<3008012 ){
   362         -    *pzErrMsg = sqlite3_mprintf(
   363         -        "carray() requires SQLite 3.8.12 or later");
   364         -    return SQLITE_ERROR;
   365         -  }
   366    361     rc = sqlite3_create_module(db, "carray", &carrayModule, 0);
   367    362   #endif
   368    363     return rc;
   369    364   }

Changes to ext/misc/csv.c.

    44     44   #include <string.h>
    45     45   #include <stdlib.h>
    46     46   #include <assert.h>
    47     47   #include <stdarg.h>
    48     48   #include <ctype.h>
    49     49   #include <stdio.h>
    50     50   
           51  +#ifndef SQLITE_OMIT_VIRTUALTABLE
           52  +
    51     53   /*
    52     54   ** A macro to hint to the compiler that a function should not be
    53     55   ** inlined.
    54     56   */
    55     57   #if defined(__GNUC__)
    56     58   #  define CSV_NOINLINE  __attribute__((noinline))
    57     59   #elif defined(_MSC_VER) && _MSC_VER>=1310
................................................................................
   830    832     0,                       /* xCommit */
   831    833     0,                       /* xRollback */
   832    834     0,                       /* xFindMethod */
   833    835     0,                       /* xRename */
   834    836   };
   835    837   #endif /* SQLITE_TEST */
   836    838   
          839  +#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */
   837    840   
   838    841   
   839    842   #ifdef _WIN32
   840    843   __declspec(dllexport)
   841    844   #endif
   842    845   /* 
   843    846   ** This routine is called when the extension is loaded.  The new
................................................................................
   845    848   ** connection.
   846    849   */
   847    850   int sqlite3_csv_init(
   848    851     sqlite3 *db, 
   849    852     char **pzErrMsg, 
   850    853     const sqlite3_api_routines *pApi
   851    854   ){
          855  +#ifndef SQLITE_OMIT_VIRTUALTABLE	
   852    856     int rc;
   853    857     SQLITE_EXTENSION_INIT2(pApi);
   854    858     rc = sqlite3_create_module(db, "csv", &CsvModule, 0);
   855    859   #ifdef SQLITE_TEST
   856    860     if( rc==SQLITE_OK ){
   857    861       rc = sqlite3_create_module(db, "csv_wr", &CsvModuleFauxWrite, 0);
   858    862     }
   859    863   #endif
   860    864     return rc;
          865  +#else
          866  +  return SQLITE_OK;
          867  +#endif
   861    868   }

Changes to ext/rbu/rbudiff.test.

   199    199       CREATE VIRTUAL TABLE 'x''y' USING fts3;
   200    200       INSERT INTO 'x''y' VALUES('one two three');
   201    201       INSERT INTO 'x''y' VALUES('four five six');
   202    202     } {
   203    203       DELETE FROM 'x''y' WHERE rowid = 1;
   204    204       INSERT INTO 'x''y' VALUES('one two three');
   205    205     }
   206         -
   207    206   } {
   208    207   
   209    208     forcedelete test.db test.db2
   210    209     sqlite3 db test.db
   211    210     db eval "$init"
   212    211     sqlite3 db test.db2
   213    212     db eval "$init ; $mod"
................................................................................
   217    216       set sql [get_vtab_rbudiff_sql test.db test.db2]
   218    217       apply_rbudiff $sql test.db
   219    218     } {SQLITE_DONE}
   220    219     do_test 2.$tn.2 { rbudiff_cksum test.db } [rbudiff_cksum test.db2]
   221    220   }
   222    221   
   223    222   }
          223  +
          224  +ifcapable fts5 {
          225  +  foreach {tn init mod} {
          226  +    1 {
          227  +      CREATE VIRTUAL TABLE t1 USING fts5(c);
          228  +      INSERT INTO t1 VALUES('a b c');
          229  +      INSERT INTO t1 VALUES('a b c');
          230  +    } {
          231  +      DELETE FROM t1 WHERE rowid = 1;
          232  +      INSERT INTO t1 VALUES('a b c');
          233  +    }
          234  +
          235  +    2 {
          236  +      CREATE VIRTUAL TABLE t1 USING FTs5(c);
          237  +      INSERT INTO t1 VALUES('a b c');
          238  +      INSERT INTO t1 VALUES('a b c');
          239  +    } {
          240  +      DELETE FROM t1 WHERE rowid = 1;
          241  +      INSERT INTO t1 VALUES('a b c');
          242  +    }
          243  +
          244  +    3 {
          245  +      creAte    virTUal
          246  +tablE t1 USING FTs5(c);
          247  +      INSERT INTO t1 VALUES('a b c');
          248  +      INSERT INTO t1 VALUES('a b c');
          249  +    } {
          250  +      DELETE FROM t1 WHERE rowid = 1;
          251  +      INSERT INTO t1 VALUES('a b c');
          252  +    }
          253  +
          254  +  } {
          255  +    forcedelete test.db test.db2
          256  +    sqlite3 db test.db
          257  +    db eval "$init"
          258  +    sqlite3 db test.db2
          259  +    db eval "$init ; $mod"
          260  +    db eval { INSERT INTO t1(t1) VALUES('optimize') }
          261  +    db close
          262  +
          263  +    do_test 3.$tn.1 {
          264  +      set sql [get_vtab_rbudiff_sql test.db test.db2]
          265  +      apply_rbudiff $sql test.db
          266  +    } {SQLITE_DONE}
          267  +
          268  +    sqlite3 db test.db
          269  +    sqlite3 db2 test.db2
          270  +    do_test 3.$tn.2 { 
          271  +      db2 eval { SELECT * FROM t1 ORDER BY rowid }
          272  +    } [db eval { SELECT * FROM t1 ORDER BY rowid }]
          273  +
          274  +    do_test 3.$tn.3 { 
          275  +      db2 eval { INSERT INTO t1(t1) VALUES('integrity-check') }
          276  +    } {}
          277  +
          278  +    db close
          279  +    db2 close
          280  +  }
          281  +}
   224    282   
   225    283   finish_test
   226    284   

Changes to src/alter.c.

   597    597     const char *zDb;          /* Database name */
   598    598     const char *zTab;         /* Table name */
   599    599     char *zCol;               /* Null-terminated column definition */
   600    600     Column *pCol;             /* The new column */
   601    601     Expr *pDflt;              /* Default value for the new column */
   602    602     sqlite3 *db;              /* The database connection; */
   603    603     Vdbe *v = pParse->pVdbe;  /* The prepared statement under construction */
          604  +  int r1;                   /* Temporary registers */
   604    605   
   605    606     db = pParse->db;
   606    607     if( pParse->nErr || db->mallocFailed ) return;
   607    608     assert( v!=0 );
   608    609     pNew = pParse->pNewTable;
   609    610     assert( pNew );
   610    611   
................................................................................
   691    692         zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
   692    693         zTab
   693    694       );
   694    695       sqlite3DbFree(db, zCol);
   695    696       db->flags = savedDbFlags;
   696    697     }
   697    698   
   698         -  /* If the default value of the new column is NULL, then the file
   699         -  ** format to 2. If the default value of the new column is not NULL,
   700         -  ** the file format be 3.  Back when this feature was first added
   701         -  ** in 2006, we went to the trouble to upgrade the file format to the
   702         -  ** minimum support values.  But 10-years on, we can assume that all
   703         -  ** extent versions of SQLite support file-format 4, so we always and
   704         -  ** unconditionally upgrade to 4.
          699  +  /* Make sure the schema version is at least 3.  But do not upgrade
          700  +  ** from less than 3 to 4, as that will corrupt any preexisting DESC
          701  +  ** index.
   705    702     */
   706         -  sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 
   707         -                    SQLITE_MAX_FILE_FORMAT);
          703  +  r1 = sqlite3GetTempReg(pParse);
          704  +  sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
          705  +  sqlite3VdbeUsesBtree(v, iDb);
          706  +  sqlite3VdbeAddOp2(v, OP_AddImm, r1, -2);
          707  +  sqlite3VdbeAddOp2(v, OP_IfPos, r1, sqlite3VdbeCurrentAddr(v)+2);
          708  +  VdbeCoverage(v);
          709  +  sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
          710  +  sqlite3ReleaseTempReg(pParse, r1);
   708    711   
   709    712     /* Reload the schema of the modified table. */
   710    713     reloadTableSchema(pParse, pTab, pTab->zName);
   711    714   }
   712    715   
   713    716   /*
   714    717   ** This function is called by the parser after the table-name in

Changes to src/shell.c.

  2942   2942     sqlite3_finalize(pStmt);
  2943   2943     return res;
  2944   2944   }
  2945   2945   
  2946   2946   /*
  2947   2947   ** Convert a 2-byte or 4-byte big-endian integer into a native integer
  2948   2948   */
  2949         -unsigned int get2byteInt(unsigned char *a){
         2949  +static unsigned int get2byteInt(unsigned char *a){
  2950   2950     return (a[0]<<8) + a[1];
  2951   2951   }
  2952         -unsigned int get4byteInt(unsigned char *a){
         2952  +static unsigned int get4byteInt(unsigned char *a){
  2953   2953     return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
  2954   2954   }
  2955   2955   
  2956   2956   /*
  2957   2957   ** Implementation of the ".info" command.
  2958   2958   **
  2959   2959   ** Return 1 on error, 2 to exit, and 0 otherwise.

Changes to test/alter3.test.

   180    180       ALTER TABLE t1 ADD c;
   181    181       SELECT * FROM t1;
   182    182     }
   183    183   } {1 100 {} 2 300 {}}
   184    184   if {!$has_codec} {
   185    185     do_test alter3-3.3 {
   186    186       get_file_format
   187         -  } {4}
          187  +  } {3}
   188    188   }
   189    189   ifcapable schema_version {
   190    190     do_test alter3-3.4 {
   191    191       execsql {
   192    192         PRAGMA schema_version;
   193    193       }
   194    194     } {11}
................................................................................
   216    216       ALTER TABLE t1 ADD c DEFAULT 'hello world';
   217    217       SELECT * FROM t1;
   218    218     }
   219    219   } {1 100 {hello world} 2 300 {hello world}}
   220    220   if {!$has_codec} {
   221    221     do_test alter3-4.3 {
   222    222       get_file_format
   223         -  } {4}
          223  +  } {3}
   224    224   }
   225    225   ifcapable schema_version {
   226    226     do_test alter3-4.4 {
   227    227       execsql {
   228    228         PRAGMA schema_version;
   229    229       }
   230    230     } {21}
................................................................................
   266    266           PRAGMA aux.schema_version;
   267    267         }
   268    268       } {31}
   269    269     }
   270    270     if {!$has_codec} {
   271    271       do_test alter3-5.5 {
   272    272         list [get_file_format test2.db] [get_file_format]
   273         -    } {4 4}
          273  +    } {3 3}
   274    274     }
   275    275     do_test alter3-5.6 {
   276    276       execsql {
   277    277         ALTER TABLE aux.t1 ADD COLUMN d DEFAULT 1000;
   278    278         SELECT sql FROM aux.sqlite_master;
   279    279       }
   280    280     } {{CREATE TABLE t1(a,b, c VARCHAR(128), d DEFAULT 1000)}}
................................................................................
   343    343       } {1}
   344    344       do_test alter3-7.2 {
   345    345         execsql {
   346    346           CREATE TABLE abc(a, b, c);
   347    347           ALTER TABLE abc ADD d DEFAULT NULL;
   348    348         }
   349    349         get_file_format
   350         -    } {4}
          350  +    } {3}
   351    351       do_test alter3-7.3 {
   352    352         execsql {
   353    353           ALTER TABLE abc ADD e DEFAULT 10;
   354    354         }
   355    355         get_file_format
   356         -    } {4}
          356  +    } {3}
   357    357       do_test alter3-7.4 {
   358    358         execsql {
   359    359           ALTER TABLE abc ADD f DEFAULT NULL;
   360    360         }
   361    361         get_file_format
   362         -    } {4}
          362  +    } {3}
   363    363       do_test alter3-7.5 {
   364    364         execsql {
   365    365           VACUUM;
   366    366         }
   367    367         get_file_format
   368    368       } {1}
   369    369     }

Changes to test/alter4.test.

   350    350     real     9.22337203685478e+18
   351    351   }
   352    352   
   353    353   do_execsql_test alter4-9.3 { 
   354    354     ALTER TABLE t5 ADD COLUMN c INTEGER DEFAULT (-(-9223372036854775808));
   355    355     SELECT typeof(c), c FROM t5;
   356    356   } {real 9.22337203685478e+18}
          357  +
          358  +# Confirm that doing an ALTER TABLE on a legacy format database
          359  +# does not corrupt DESC indexes.
          360  +#
          361  +# Ticket https://www.sqlite.org/src/tktview/f68bf68513a1c
          362  +#
          363  +do_test alter4-10.1 {
          364  +  db close
          365  +  sqlite3 db :memory:
          366  +  db eval {
          367  +    PRAGMA legacy_file_format=on;
          368  +    CREATE TABLE t1(a,b,c);
          369  +    CREATE INDEX t1a ON t1(a DESC);
          370  +    INSERT INTO t1 VALUES(1,2,3);
          371  +    INSERT INTO t1 VALUES(2,3,4);
          372  +    ALTER TABLE t1 ADD COLUMN d;
          373  +    PRAGMA integrity_check;
          374  +  }
          375  +} {ok}
   357    376   
   358    377   finish_test

Added test/vacuummem.test.

            1  +# 2005 February 15
            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.  The
           12  +# focus of this file is testing that the VACUUM statement correctly
           13  +# frees any memory used for a temporary cache.
           14  +#
           15  +
           16  +set testdir [file dirname $argv0]
           17  +source $testdir/tester.tcl
           18  +set testprefix vacuummem
           19  +
           20  +proc memory_used {} { 
           21  +  set stat [sqlite3_status SQLITE_STATUS_MEMORY_USED 1]  
           22  +  lindex $stat 1
           23  +}
           24  +
           25  +do_execsql_test 1.0 {
           26  +  PRAGMA cache_size = -2000;
           27  +  CREATE TABLE t1(a, b, c);
           28  +
           29  +  WITH r(i) AS (
           30  +    SELECT 1 UNION ALL SELECT i+1 FROM r WHERE i<100000
           31  +  )
           32  +  INSERT INTO t1 SELECT randomblob(100),randomblob(100),randomblob(100) FROM r;
           33  +
           34  +  CREATE INDEX t1a ON t1(a);
           35  +  CREATE INDEX t1b ON t1(b);
           36  +  CREATE INDEX t1c ON t1(c);
           37  +}
           38  +
           39  +do_test 1.1 { memory_used } {#/2300000/}
           40  +
           41  +do_execsql_test 1.2 VACUUM
           42  +
           43  +do_test 1.3 { memory_used } {#/2300000/}
           44  +
           45  +do_execsql_test 1.4 {
           46  +  SELECT count(*) FROM t1 WHERE +a IS NOT NULL
           47  +} {100000}
           48  +
           49  +do_test 1.5 { memory_used } {#/2300000/}
           50  +
           51  +
           52  +
           53  +finish_test
           54  +

Changes to tool/lempar.c.

   752    752   ){
   753    753     ParseARG_FETCH;
   754    754   #ifndef NDEBUG
   755    755     if( yyTraceFILE ){
   756    756       fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
   757    757     }
   758    758   #endif
          759  +#ifndef YYNOERRORRECOVERY
          760  +  yypParser->yyerrcnt = -1;
          761  +#endif
   759    762     assert( yypParser->yytos==yypParser->yystack );
   760    763     /* Here code is inserted which will be executed whenever the
   761    764     ** parser accepts */
   762    765   /*********** Begin %parse_accept code *****************************************/
   763    766   %%
   764    767   /*********** End %parse_accept code *******************************************/
   765    768     ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
................................................................................
   894    897         ** do any kind of error recovery.  Instead, simply invoke the syntax
   895    898         ** error routine and continue going as if nothing had happened.
   896    899         **
   897    900         ** Applications can set this macro (for example inside %include) if
   898    901         ** they intend to abandon the parse upon the first syntax error seen.
   899    902         */
   900    903         yy_syntax_error(yypParser,yymajor, yyminor);
   901         -#ifndef YYNOERRORRECOVERY
   902         -      yypParser->yyerrcnt = -1;
   903         -#endif
   904    904         yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
   905    905         yymajor = YYNOCODE;
   906    906         
   907    907   #else  /* YYERRORSYMBOL is not defined */
   908    908         /* This is what we do if the grammar does not define ERROR:
   909    909         **
   910    910         **  * Report an error message, and throw away the input token.

Changes to tool/sqldiff.c.

  1818   1818   ** tables to process within the database.
  1819   1819   */
  1820   1820   const char *all_tables_sql(){
  1821   1821     if( g.bHandleVtab ){
  1822   1822       int rc;
  1823   1823     
  1824   1824       rc = sqlite3_exec(g.db, 
  1825         -        "CREATE TEMP TABLE tblmap(module, postfix);"
         1825  +        "CREATE TEMP TABLE tblmap(module COLLATE nocase, postfix);"
  1826   1826           "INSERT INTO temp.tblmap VALUES"
  1827   1827           "('fts3', '_content'), ('fts3', '_segments'), ('fts3', '_segdir'),"
  1828   1828     
  1829   1829           "('fts4', '_content'), ('fts4', '_segments'), ('fts4', '_segdir'),"
  1830   1830           "('fts4', '_docsize'), ('fts4', '_stat'),"
  1831   1831     
  1832   1832           "('fts5', '_data'), ('fts5', '_idx'), ('fts5', '_content'),"