[sql] Remove fts2 patches.

third_party/sqlite/src/ext/fts2/fts2.c

 /* fts2 has a design flaw which can lead to database corruption (see
 ** below).  It is recommended not to use it any longer, instead use
 ** fts3 (or higher).  If you believe that your use of fts2 is safe,
 ** add -DSQLITE_ENABLE_BROKEN_FTS2=1 to your CFLAGS.
 */
 #if (!defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2)) \
         && !defined(SQLITE_ENABLE_BROKEN_FTS2)
 #error fts2 has a design flaw and has been deprecated.
 #endif
 /* The flaw is that fts2 uses the content table's unaliased rowid as
@@ skipping 19 matching lines @@
 **
 **    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 is an SQLite module implementing full-text search.
 */
 
-/* TODO(shess): To make it easier to spot changes without groveling
-** through changelogs, I've defined GEARS_FTS2_CHANGES to call them
-** out, and I will document them here.  On imports, these changes
-** should be reviewed to make sure they are still present, or are
-** dropped as appropriate.
-**
-** SQLite core adds the custom function fts2_tokenizer() to be used
-** for defining new tokenizers.  The second parameter is a vtable
-** pointer encoded as a blob.  Obviously this cannot be exposed to
-** Gears callers for security reasons.  It could be suppressed in the
-** authorizer, but for now I have simply commented the definition out.
-*/
-#define GEARS_FTS2_CHANGES 1
-
 /*
 ** The code in this file is only compiled if:
 **
 **     * The FTS2 module is being built as an extension
 **       (in which case SQLITE_CORE is not defined), or
 **
 **     * The FTS2 module is being built into the core of
 **       SQLite (in which case SQLITE_ENABLE_FTS2 is defined).
 */
 
@@ skipping 253 matching lines @@
 #endif
 
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include "fts2.h"
 #include "fts2_hash.h"
 #include "fts2_tokenizer.h"
 #include "sqlite3.h"
-#ifndef SQLITE_CORE
-# include "sqlite3ext.h"
-  SQLITE_EXTENSION_INIT1
-#endif
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
 
 
 /* TODO(shess) MAN, this thing needs some refactoring.  At minimum, it
 ** would be nice to order the file better, perhaps something along the
 ** lines of:
 **
 **  - utility functions
 **  - table setup functions
 **  - table update functions
 **  - table query functions
 **
 ** Put the query functions last because they're likely to reference
 ** typedefs or functions from the table update section.
 */
 
 #if 0
 # define TRACE(A)  printf A; fflush(stdout)
 #else
 # define TRACE(A)
 #endif
 
-#if 0
-/* Useful to set breakpoints.  See main.c sqlite3Corrupt(). */
-static int fts2Corrupt(void){
-  return SQLITE_CORRUPT;
-}
-# define SQLITE_CORRUPT_BKPT fts2Corrupt()
-#else
-# define SQLITE_CORRUPT_BKPT SQLITE_CORRUPT
-#endif
-
 /* It is not safe to call isspace(), tolower(), or isalnum() on
 ** hi-bit-set characters.  This is the same solution used in the
 ** tokenizer.
 */
 /* TODO(shess) The snippet-generation code should be using the
 ** tokenizer-generated tokens rather than doing its own local
 ** tokenization.
 */
 /* TODO(shess) Is __isascii() a portable version of (c&0x80)==0? */
 static int safe_isspace(char c){
@@ skipping 68 matching lines @@
     vu >>= 7;
   }while( vu!=0 );
   q[-1] &= 0x7f;  /* turn off high bit in final byte */
   assert( q - (unsigned char *)p <= VARINT_MAX );
   return (int) (q - (unsigned char *)p);
 }
 
 /* Read a 64-bit variable-length integer from memory starting at p[0].
  * Return the number of bytes read, or 0 on error.
  * The value is stored in *v. */
-static int getVarintSafe(const char *p, sqlite_int64 *v, int max){
+static int getVarint(const char *p, sqlite_int64 *v){
   const unsigned char *q = (const unsigned char *) p;
   sqlite_uint64 x = 0, y = 1;
-  if( max>VARINT_MAX ) max = VARINT_MAX;
-  while( max && (*q & 0x80) == 0x80 ){
-    max--;
+  while( (*q & 0x80) == 0x80 ){
     x += y * (*q++ & 0x7f);
     y <<= 7;
-  }
-  if ( !max ){
-    assert( 0 );
-    return 0;  /* tried to read too much; bad data */
+    if( q - (unsigned char *)p >= VARINT_MAX ){  /* bad data */
+      assert( 0 );
+      return 0;
+    }
   }
   x += y * (*q++);
   *v = (sqlite_int64) x;
   return (int) (q - (unsigned char *)p);
 }
 
-static int getVarint(const char *p, sqlite_int64 *v){
-  return getVarintSafe(p, v, VARINT_MAX);
-}
-
-static int getVarint32Safe(const char *p, int *pi, int max){
+static int getVarint32(const char *p, int *pi){
  sqlite_int64 i;
- int ret = getVarintSafe(p, &i, max);
- if( !ret ) return ret;
+ int ret = getVarint(p, &i);
  *pi = (int) i;
  assert( *pi==i );
  return ret;
 }
 
-static int getVarint32(const char* p, int *pi){
-  return getVarint32Safe(p, pi, VARINT_MAX);
-}
-
 /*******************************************************************/
 /* DataBuffer is used to collect data into a buffer in piecemeal
 ** fashion.  It implements the usual distinction between amount of
 ** data currently stored (nData) and buffer capacity (nCapacity).
 **
 ** dataBufferInit - create a buffer with given initial capacity.
 ** dataBufferReset - forget buffer's data, retaining capacity.
 ** dataBufferDestroy - free buffer's data.
 ** dataBufferSwap - swap contents of two buffers.
 ** dataBufferExpand - expand capacity without adding data.
@@ skipping 148 matching lines @@
   DocListType iType;
   const char *pData;
   int nData;
 
   sqlite_int64 iDocid;
   int nElement;
 } DLReader;
 
 static int dlrAtEnd(DLReader *pReader){
   assert( pReader->nData>=0 );
-  return pReader->nData<=0;
+  return pReader->nData==0;
 }
 static sqlite_int64 dlrDocid(DLReader *pReader){
   assert( !dlrAtEnd(pReader) );
   return pReader->iDocid;
 }
 static const char *dlrDocData(DLReader *pReader){
   assert( !dlrAtEnd(pReader) );
   return pReader->pData;
 }
 static int dlrDocDataBytes(DLReader *pReader){
   assert( !dlrAtEnd(pReader) );
   return pReader->nElement;
 }
 static int dlrAllDataBytes(DLReader *pReader){
   assert( !dlrAtEnd(pReader) );
   return pReader->nData;
 }
 /* TODO(shess) Consider adding a field to track iDocid varint length
 ** to make these two functions faster.  This might matter (a tiny bit)
 ** for queries.
 */
 static const char *dlrPosData(DLReader *pReader){
   sqlite_int64 iDummy;
-  int n = getVarintSafe(pReader->pData, &iDummy, pReader->nElement);
-  if( !n ) return NULL;
+  int n = getVarint(pReader->pData, &iDummy);
   assert( !dlrAtEnd(pReader) );
   return pReader->pData+n;
 }
 static int dlrPosDataLen(DLReader *pReader){
   sqlite_int64 iDummy;
   int n = getVarint(pReader->pData, &iDummy);
   assert( !dlrAtEnd(pReader) );
   return pReader->nElement-n;
 }
-static int dlrStep(DLReader *pReader){
+static void dlrStep(DLReader *pReader){
   assert( !dlrAtEnd(pReader) );
 
   /* Skip past current doclist element. */
   assert( pReader->nElement<=pReader->nData );
   pReader->pData += pReader->nElement;
   pReader->nData -= pReader->nElement;
 
   /* If there is more data, read the next doclist element. */
-  if( pReader->nData>0 ){
+  if( pReader->nData!=0 ){
     sqlite_int64 iDocidDelta;
-    int nTotal = 0;
-    int iDummy, n = getVarintSafe(pReader->pData, &iDocidDelta, pReader->nData);
-    if( !n ) return SQLITE_CORRUPT_BKPT;
-    nTotal += n;
+    int iDummy, n = getVarint(pReader->pData, &iDocidDelta);
     pReader->iDocid += iDocidDelta;
     if( pReader->iType>=DL_POSITIONS ){
+      assert( n<pReader->nData );
       while( 1 ){
-        n = getVarint32Safe(pReader->pData+nTotal, &iDummy,
-                            pReader->nData-nTotal);
-        if( !n ) return SQLITE_CORRUPT_BKPT;
-        nTotal += n;
+        n += getVarint32(pReader->pData+n, &iDummy);
+        assert( n<=pReader->nData );
         if( iDummy==POS_END ) break;
         if( iDummy==POS_COLUMN ){
-          n = getVarint32Safe(pReader->pData+nTotal, &iDummy,
-                              pReader->nData-nTotal);
-          if( !n ) return SQLITE_CORRUPT_BKPT;
-          nTotal += n;
+          n += getVarint32(pReader->pData+n, &iDummy);
+          assert( n<pReader->nData );
         }else if( pReader->iType==DL_POSITIONS_OFFSETS ){
-          n = getVarint32Safe(pReader->pData+nTotal, &iDummy,
-                              pReader->nData-nTotal);
-          if( !n ) return SQLITE_CORRUPT_BKPT;
-          nTotal += n;
-          n = getVarint32Safe(pReader->pData+nTotal, &iDummy,
-                              pReader->nData-nTotal);
-          if( !n ) return SQLITE_CORRUPT_BKPT;
-          nTotal += n;
+          n += getVarint32(pReader->pData+n, &iDummy);
+          n += getVarint32(pReader->pData+n, &iDummy);
+          assert( n<pReader->nData );
         }
       }
     }
-    pReader->nElement = nTotal;
+    pReader->nElement = n;
     assert( pReader->nElement<=pReader->nData );
   }
-  return SQLITE_OK;
 }
-static void dlrDestroy(DLReader *pReader){
-  SCRAMBLE(pReader);
-}
-static int dlrInit(DLReader *pReader, DocListType iType,
-                   const char *pData, int nData){
-  int rc;
+static void dlrInit(DLReader *pReader, DocListType iType,
+                    const char *pData, int nData){
   assert( pData!=NULL && nData!=0 );
   pReader->iType = iType;
   pReader->pData = pData;
   pReader->nData = nData;
   pReader->nElement = 0;
   pReader->iDocid = 0;
 
   /* Load the first element's data.  There must be a first element. */
-  rc = dlrStep(pReader);
-  if( rc!=SQLITE_OK ) dlrDestroy(pReader);
-  return rc;
+  dlrStep(pReader);
+}
+static void dlrDestroy(DLReader *pReader){
+  SCRAMBLE(pReader);
 }
 
 #ifndef NDEBUG
 /* Verify that the doclist can be validly decoded.  Also returns the
 ** last docid found because it is convenient in other assertions for
 ** DLWriter.
 */
 static void docListValidate(DocListType iType, const char *pData, int nData,
                             sqlite_int64 *pLastDocid){
   sqlite_int64 iPrevDocid = 0;
@@ skipping 66 matching lines @@
 **
 ** iLastDocid is the final docid in the doclist in pData.  It is
 ** needed to create the new iPrevDocid for future delta-encoding.  The
 ** code could decode the passed doclist to recreate iLastDocid, but
 ** the only current user (docListMerge) already has decoded this
 ** information.
 */
 /* TODO(shess) This has become just a helper for docListMerge.
 ** Consider a refactor to make this cleaner.
 */
-static int dlwAppend(DLWriter *pWriter,
-                     const char *pData, int nData,
-                     sqlite_int64 iFirstDocid, sqlite_int64 iLastDocid){
+static void dlwAppend(DLWriter *pWriter,
+                      const char *pData, int nData,
+                      sqlite_int64 iFirstDocid, sqlite_int64 iLastDocid){
   sqlite_int64 iDocid = 0;
   char c[VARINT_MAX];
   int nFirstOld, nFirstNew;     /* Old and new varint len of first docid. */
 #ifndef NDEBUG
   sqlite_int64 iLastDocidDelta;
 #endif
 
   /* Recode the initial docid as delta from iPrevDocid. */
-  nFirstOld = getVarintSafe(pData, &iDocid, nData);
-  if( !nFirstOld ) return SQLITE_CORRUPT_BKPT;
+  nFirstOld = getVarint(pData, &iDocid);
   assert( nFirstOld<nData || (nFirstOld==nData && pWriter->iType==DL_DOCIDS) );
   nFirstNew = putVarint(c, iFirstDocid-pWriter->iPrevDocid);
 
   /* Verify that the incoming doclist is valid AND that it ends with
   ** the expected docid.  This is essential because we'll trust this
   ** docid in future delta-encoding.
   */
   ASSERT_VALID_DOCLIST(pWriter->iType, pData, nData, &iLastDocidDelta);
   assert( iLastDocid==iFirstDocid-iDocid+iLastDocidDelta );
 
   /* Append recoded initial docid and everything else.  Rest of docids
   ** should have been delta-encoded from previous initial docid.
   */
   if( nFirstOld<nData ){
     dataBufferAppend2(pWriter->b, c, nFirstNew,
                       pData+nFirstOld, nData-nFirstOld);
   }else{
     dataBufferAppend(pWriter->b, c, nFirstNew);
   }
   pWriter->iPrevDocid = iLastDocid;
-  return SQLITE_OK;
 }
-static int dlwCopy(DLWriter *pWriter, DLReader *pReader){
-  return dlwAppend(pWriter, dlrDocData(pReader), dlrDocDataBytes(pReader),
-                   dlrDocid(pReader), dlrDocid(pReader));
+static void dlwCopy(DLWriter *pWriter, DLReader *pReader){
+  dlwAppend(pWriter, dlrDocData(pReader), dlrDocDataBytes(pReader),
+            dlrDocid(pReader), dlrDocid(pReader));
 }
 static void dlwAdd(DLWriter *pWriter, sqlite_int64 iDocid){
   char c[VARINT_MAX];
   int n = putVarint(c, iDocid-pWriter->iPrevDocid);
 
   /* Docids must ascend. */
   assert( !pWriter->has_iPrevDocid || iDocid>pWriter->iPrevDocid );
   assert( pWriter->iType==DL_DOCIDS );
 
   dataBufferAppend(pWriter->b, c, n);
@@ skipping 40 matching lines @@
   return pReader->iPosition;
 }
 static int plrStartOffset(PLReader *pReader){
   assert( !plrAtEnd(pReader) );
   return pReader->iStartOffset;
 }
 static int plrEndOffset(PLReader *pReader){
   assert( !plrAtEnd(pReader) );
   return pReader->iEndOffset;
 }
-static int plrStep(PLReader *pReader){
-  int i, n, nTotal = 0;
+static void plrStep(PLReader *pReader){
+  int i, n;
 
   assert( !plrAtEnd(pReader) );
 
-  if( pReader->nData<=0 ){
+  if( pReader->nData==0 ){
     pReader->pData = NULL;
-    return SQLITE_OK;
+    return;
   }
 
-  n = getVarint32Safe(pReader->pData, &i, pReader->nData);
-  if( !n ) return SQLITE_CORRUPT_BKPT;
-  nTotal += n;
+  n = getVarint32(pReader->pData, &i);
   if( i==POS_COLUMN ){
-    n = getVarint32Safe(pReader->pData+nTotal, &pReader->iColumn,
-                        pReader->nData-nTotal);
-    if( !n ) return SQLITE_CORRUPT_BKPT;
-    nTotal += n;
+    n += getVarint32(pReader->pData+n, &pReader->iColumn);
     pReader->iPosition = 0;
     pReader->iStartOffset = 0;
-    n = getVarint32Safe(pReader->pData+nTotal, &i, pReader->nData-nTotal);
-    if( !n ) return SQLITE_CORRUPT_BKPT;
-    nTotal += n;
+    n += getVarint32(pReader->pData+n, &i);
   }
   /* Should never see adjacent column changes. */
   assert( i!=POS_COLUMN );
 
   if( i==POS_END ){
-    assert( nTotal<=pReader->nData );
     pReader->nData = 0;
     pReader->pData = NULL;
-    return SQLITE_OK;
+    return;
   }
 
   pReader->iPosition += i-POS_BASE;
   if( pReader->iType==DL_POSITIONS_OFFSETS ){
-    n = getVarint32Safe(pReader->pData+nTotal, &i, pReader->nData-nTotal);
-    if( !n ) return SQLITE_CORRUPT_BKPT;
-    nTotal += n;
+    n += getVarint32(pReader->pData+n, &i);
     pReader->iStartOffset += i;
-    n = getVarint32Safe(pReader->pData+nTotal, &i, pReader->nData-nTotal);
-    if( !n ) return SQLITE_CORRUPT_BKPT;
-    nTotal += n;
+    n += getVarint32(pReader->pData+n, &i);
     pReader->iEndOffset = pReader->iStartOffset+i;
   }
-  assert( nTotal<=pReader->nData );
-  pReader->pData += nTotal;
-  pReader->nData -= nTotal;
-  return SQLITE_OK;
+  assert( n<=pReader->nData );
+  pReader->pData += n;
+  pReader->nData -= n;
 }
 
-static void plrDestroy(PLReader *pReader){
-  SCRAMBLE(pReader);
-}
-
-static int plrInit(PLReader *pReader, DLReader *pDLReader){
-  int rc;
+static void plrInit(PLReader *pReader, DLReader *pDLReader){
   pReader->pData = dlrPosData(pDLReader);
   pReader->nData = dlrPosDataLen(pDLReader);
   pReader->iType = pDLReader->iType;
   pReader->iColumn = 0;
   pReader->iPosition = 0;
   pReader->iStartOffset = 0;
   pReader->iEndOffset = 0;
-  rc = plrStep(pReader);
-  if( rc!=SQLITE_OK ) plrDestroy(pReader);
-  return rc;
+  plrStep(pReader);
+}
+static void plrDestroy(PLReader *pReader){
+  SCRAMBLE(pReader);
 }
 
 /*******************************************************************/
 /* PLWriter is used in constructing a document's position list.  As a
 ** convenience, if iType is DL_DOCIDS, PLWriter becomes a no-op.
 ** PLWriter writes to the associated DLWriter's buffer.
 **
 ** plwInit - init for writing a document's poslist.
 ** plwDestroy - clear a writer.
 ** plwAdd - append position and offset information.
@@ skipping 165 matching lines @@
 /* Copy the doclist data of iType in pData/nData into *out, trimming
 ** unnecessary data as we go.  Only columns matching iColumn are
 ** copied, all columns copied if iColumn is -1.  Elements with no
 ** matching columns are dropped.  The output is an iOutType doclist.
 */
 /* NOTE(shess) This code is only valid after all doclists are merged.
 ** If this is run before merges, then doclist items which represent
 ** deletion will be trimmed, and will thus not effect a deletion
 ** during the merge.
 */
-static int docListTrim(DocListType iType, const char *pData, int nData,
-                       int iColumn, DocListType iOutType, DataBuffer *out){
+static void docListTrim(DocListType iType, const char *pData, int nData,
+                        int iColumn, DocListType iOutType, DataBuffer *out){
   DLReader dlReader;
   DLWriter dlWriter;
-  int rc;
 
   assert( iOutType<=iType );
 
-  rc = dlrInit(&dlReader, iType, pData, nData);
-  if( rc!=SQLITE_OK ) return rc;
+  dlrInit(&dlReader, iType, pData, nData);
   dlwInit(&dlWriter, iOutType, out);
 
   while( !dlrAtEnd(&dlReader) ){
     PLReader plReader;
     PLWriter plWriter;
     int match = 0;
 
-    rc = plrInit(&plReader, &dlReader);
-    if( rc!=SQLITE_OK ) break;
+    plrInit(&plReader, &dlReader);
 
     while( !plrAtEnd(&plReader) ){
       if( iColumn==-1 || plrColumn(&plReader)==iColumn ){
         if( !match ){
           plwInit(&plWriter, &dlWriter, dlrDocid(&dlReader));
           match = 1;
         }
         plwAdd(&plWriter, plrColumn(&plReader), plrPosition(&plReader),
                plrStartOffset(&plReader), plrEndOffset(&plReader));
       }
-      rc = plrStep(&plReader);
-      if( rc!=SQLITE_OK ){
-        plrDestroy(&plReader);
-        goto err;
-      }
+      plrStep(&plReader);
     }
     if( match ){
       plwTerminate(&plWriter);
       plwDestroy(&plWriter);
     }
 
     plrDestroy(&plReader);
-    rc = dlrStep(&dlReader);
-    if( rc!=SQLITE_OK ) break;
+    dlrStep(&dlReader);
   }
-err:
   dlwDestroy(&dlWriter);
   dlrDestroy(&dlReader);
-  return rc;
 }
 
 /* Used by docListMerge() to keep doclists in the ascending order by
 ** docid, then ascending order by age (so the newest comes first).
 */
 typedef struct OrderedDLReader {
   DLReader *pReader;
 
   /* TODO(shess) If we assume that docListMerge pReaders is ordered by
   ** age (which we do), then we could use pReader comparisons to break
@@ skipping 36 matching lines @@
 }
 
 /* Given an array of doclist readers, merge their doclist elements
 ** into out in sorted order (by docid), dropping elements from older
 ** readers when there is a duplicate docid.  pReaders is assumed to be
 ** ordered by age, oldest first.
 */
 /* TODO(shess) nReaders must be <= MERGE_COUNT.  This should probably
 ** be fixed.
 */
-static int docListMerge(DataBuffer *out,
-                        DLReader *pReaders, int nReaders){
+static void docListMerge(DataBuffer *out,
+                         DLReader *pReaders, int nReaders){
   OrderedDLReader readers[MERGE_COUNT];
   DLWriter writer;
   int i, n;
   const char *pStart = 0;
   int nStart = 0;
   sqlite_int64 iFirstDocid = 0, iLastDocid = 0;
-  int rc = SQLITE_OK;
 
   assert( nReaders>0 );
   if( nReaders==1 ){
     dataBufferAppend(out, dlrDocData(pReaders), dlrAllDataBytes(pReaders));
-    return SQLITE_OK;
+    return;
   }
 
   assert( nReaders<=MERGE_COUNT );
   n = 0;
   for(i=0; i<nReaders; i++){
     assert( pReaders[i].iType==pReaders[0].iType );
     readers[i].pReader = pReaders+i;
     readers[i].idx = i;
     n += dlrAllDataBytes(&pReaders[i]);
   }
@@ skipping 12 matching lines @@
     sqlite_int64 iDocid = dlrDocid(readers[0].pReader);
 
     /* If this is a continuation of the current buffer to copy, extend
     ** that buffer.  memcpy() seems to be more efficient if it has a
     ** lots of data to copy.
     */
     if( dlrDocData(readers[0].pReader)==pStart+nStart ){
       nStart += dlrDocDataBytes(readers[0].pReader);
     }else{
       if( pStart!=0 ){
-        rc = dlwAppend(&writer, pStart, nStart, iFirstDocid, iLastDocid);
-        if( rc!=SQLITE_OK ) goto err;
+        dlwAppend(&writer, pStart, nStart, iFirstDocid, iLastDocid);
       }
       pStart = dlrDocData(readers[0].pReader);
       nStart = dlrDocDataBytes(readers[0].pReader);
       iFirstDocid = iDocid;
     }
     iLastDocid = iDocid;
-    rc = dlrStep(readers[0].pReader);
-    if( rc!=SQLITE_OK ) goto err;
+    dlrStep(readers[0].pReader);
 
     /* Drop all of the older elements with the same docid. */
     for(i=1; i<nReaders &&
              !dlrAtEnd(readers[i].pReader) &&
              dlrDocid(readers[i].pReader)==iDocid; i++){
-      rc = dlrStep(readers[i].pReader);
-      if( rc!=SQLITE_OK ) goto err;
+      dlrStep(readers[i].pReader);
     }
 
     /* Get the readers back into order. */
     while( i-->0 ){
       orderedDLReaderReorder(readers+i, nReaders-i);
     }
   }
 
   /* Copy over any remaining elements. */
-  if( nStart>0 )
-    rc = dlwAppend(&writer, pStart, nStart, iFirstDocid, iLastDocid);
-err:
+  if( nStart>0 ) dlwAppend(&writer, pStart, nStart, iFirstDocid, iLastDocid);
   dlwDestroy(&writer);
-  return rc;
 }
 
 /* Helper function for posListUnion().  Compares the current position
 ** between left and right, returning as standard C idiom of <0 if
 ** left<right, >0 if left>right, and 0 if left==right.  "End" always
 ** compares greater.
 */
 static int posListCmp(PLReader *pLeft, PLReader *pRight){
   assert( pLeft->iType==pRight->iType );
   if( pLeft->iType==DL_DOCIDS ) return 0;
@@ skipping 15 matching lines @@
   if( plrEndOffset(pLeft)>plrEndOffset(pRight) ) return 1;
 
   return 0;
 }
 
 /* Write the union of position lists in pLeft and pRight to pOut.
 ** "Union" in this case meaning "All unique position tuples".  Should
 ** work with any doclist type, though both inputs and the output
 ** should be the same type.
 */
-static int posListUnion(DLReader *pLeft, DLReader *pRight, DLWriter *pOut){
+static void posListUnion(DLReader *pLeft, DLReader *pRight, DLWriter *pOut){
   PLReader left, right;
   PLWriter writer;
-  int rc;
 
   assert( dlrDocid(pLeft)==dlrDocid(pRight) );
   assert( pLeft->iType==pRight->iType );
   assert( pLeft->iType==pOut->iType );
 
-  rc = plrInit(&left, pLeft);
-  if( rc != SQLITE_OK ) return rc;
-  rc = plrInit(&right, pRight);
-  if( rc != SQLITE_OK ){
-    plrDestroy(&left);
-    return rc;
-  }
+  plrInit(&left, pLeft);
+  plrInit(&right, pRight);
   plwInit(&writer, pOut, dlrDocid(pLeft));
 
   while( !plrAtEnd(&left) || !plrAtEnd(&right) ){
     int c = posListCmp(&left, &right);
     if( c<0 ){
       plwCopy(&writer, &left);
-      rc = plrStep(&left);
-      if( rc != SQLITE_OK ) break;
+      plrStep(&left);
     }else if( c>0 ){
       plwCopy(&writer, &right);
-      rc = plrStep(&right);
-      if( rc != SQLITE_OK ) break;
+      plrStep(&right);
     }else{
       plwCopy(&writer, &left);
-      rc = plrStep(&left);
-      if( rc != SQLITE_OK ) break;
-      rc = plrStep(&right);
-      if( rc != SQLITE_OK ) break;
+      plrStep(&left);
+      plrStep(&right);
     }
   }
 
   plwTerminate(&writer);
   plwDestroy(&writer);
   plrDestroy(&left);
   plrDestroy(&right);
-  return rc;
 }
 
 /* Write the union of doclists in pLeft and pRight to pOut.  For
 ** docids in common between the inputs, the union of the position
 ** lists is written.  Inputs and outputs are always type DL_DEFAULT.
 */
-static int docListUnion(
+static void docListUnion(
   const char *pLeft, int nLeft,
   const char *pRight, int nRight,
   DataBuffer *pOut      /* Write the combined doclist here */
 ){
   DLReader left, right;
   DLWriter writer;
-  int rc;
 
   if( nLeft==0 ){
     if( nRight!=0) dataBufferAppend(pOut, pRight, nRight);
-    return SQLITE_OK;
+    return;
   }
   if( nRight==0 ){
     dataBufferAppend(pOut, pLeft, nLeft);
-    return SQLITE_OK;
+    return;
   }
 
-  rc = dlrInit(&left, DL_DEFAULT, pLeft, nLeft);
-  if( rc!=SQLITE_OK ) return rc;
-  rc = dlrInit(&right, DL_DEFAULT, pRight, nRight);
-  if( rc!=SQLITE_OK ){
-    dlrDestroy(&left);
-    return rc;
-  }
+  dlrInit(&left, DL_DEFAULT, pLeft, nLeft);
+  dlrInit(&right, DL_DEFAULT, pRight, nRight);
   dlwInit(&writer, DL_DEFAULT, pOut);
 
   while( !dlrAtEnd(&left) || !dlrAtEnd(&right) ){
     if( dlrAtEnd(&right) ){
-      rc = dlwCopy(&writer, &left);
-      if( rc!=SQLITE_OK ) break;
-      rc = dlrStep(&left);
-      if( rc!=SQLITE_OK ) break;
+      dlwCopy(&writer, &left);
+      dlrStep(&left);
     }else if( dlrAtEnd(&left) ){
-      rc = dlwCopy(&writer, &right);
-      if( rc!=SQLITE_OK ) break;
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      dlwCopy(&writer, &right);
+      dlrStep(&right);
     }else if( dlrDocid(&left)<dlrDocid(&right) ){
-      rc = dlwCopy(&writer, &left);
-      if( rc!=SQLITE_OK ) break;
-      rc = dlrStep(&left);
-      if( rc!=SQLITE_OK ) break;
+      dlwCopy(&writer, &left);
+      dlrStep(&left);
     }else if( dlrDocid(&left)>dlrDocid(&right) ){
-      rc = dlwCopy(&writer, &right);
-      if( rc!=SQLITE_OK ) break;
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      dlwCopy(&writer, &right);
+      dlrStep(&right);
     }else{
-      rc = posListUnion(&left, &right, &writer);
-      if( rc!=SQLITE_OK ) break;
-      rc = dlrStep(&left);
-      if( rc!=SQLITE_OK ) break;
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      posListUnion(&left, &right, &writer);
+      dlrStep(&left);
+      dlrStep(&right);
     }
   }
 
   dlrDestroy(&left);
   dlrDestroy(&right);
   dlwDestroy(&writer);
-  return rc;
 }
 
 /* pLeft and pRight are DLReaders positioned to the same docid.
 **
 ** If there are no instances in pLeft or pRight where the position
 ** of pLeft is one less than the position of pRight, then this
 ** routine adds nothing to pOut.
 **
 ** If there are one or more instances where positions from pLeft
 ** are exactly one less than positions from pRight, then add a new
 ** document record to pOut.  If pOut wants to hold positions, then
 ** include the positions from pRight that are one more than a
 ** position in pLeft.  In other words:  pRight.iPos==pLeft.iPos+1.
 */
-static int posListPhraseMerge(DLReader *pLeft, DLReader *pRight,
-                              DLWriter *pOut){
+static void posListPhraseMerge(DLReader *pLeft, DLReader *pRight,
+                               DLWriter *pOut){
   PLReader left, right;
   PLWriter writer;
   int match = 0;
-  int rc;
 
   assert( dlrDocid(pLeft)==dlrDocid(pRight) );
   assert( pOut->iType!=DL_POSITIONS_OFFSETS );
 
-  rc = plrInit(&left, pLeft);
-  if( rc!=SQLITE_OK ) return rc;
-  rc = plrInit(&right, pRight);
-  if( rc!=SQLITE_OK ){
-    plrDestroy(&left);
-    return rc;
-  }
+  plrInit(&left, pLeft);
+  plrInit(&right, pRight);
 
   while( !plrAtEnd(&left) && !plrAtEnd(&right) ){
     if( plrColumn(&left)<plrColumn(&right) ){
-      rc = plrStep(&left);
-      if( rc!=SQLITE_OK ) break;
+      plrStep(&left);
     }else if( plrColumn(&left)>plrColumn(&right) ){
-      rc = plrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      plrStep(&right);
     }else if( plrPosition(&left)+1<plrPosition(&right) ){
-      rc = plrStep(&left);
-      if( rc!=SQLITE_OK ) break;
+      plrStep(&left);
     }else if( plrPosition(&left)+1>plrPosition(&right) ){
-      rc = plrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      plrStep(&right);
     }else{
       if( !match ){
         plwInit(&writer, pOut, dlrDocid(pLeft));
         match = 1;
       }
       plwAdd(&writer, plrColumn(&right), plrPosition(&right), 0, 0);
-      rc = plrStep(&left);
-      if( rc!=SQLITE_OK ) break;
-      rc = plrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      plrStep(&left);
+      plrStep(&right);
     }
   }
 
   if( match ){
     plwTerminate(&writer);
     plwDestroy(&writer);
   }
 
   plrDestroy(&left);
   plrDestroy(&right);
-  return rc;
 }
 
 /* We have two doclists with positions:  pLeft and pRight.
 ** Write the phrase intersection of these two doclists into pOut.
 **
 ** A phrase intersection means that two documents only match
 ** if pLeft.iPos+1==pRight.iPos.
 **
 ** iType controls the type of data written to pOut.  If iType is
 ** DL_POSITIONS, the positions are those from pRight.
 */
-static int docListPhraseMerge(
+static void docListPhraseMerge(
   const char *pLeft, int nLeft,
   const char *pRight, int nRight,
   DocListType iType,
   DataBuffer *pOut      /* Write the combined doclist here */
 ){
   DLReader left, right;
   DLWriter writer;
-  int rc;
 
-  if( nLeft==0 || nRight==0 ) return SQLITE_OK;
+  if( nLeft==0 || nRight==0 ) return;
 
   assert( iType!=DL_POSITIONS_OFFSETS );
 
-  rc = dlrInit(&left, DL_POSITIONS, pLeft, nLeft);
-  if( rc!=SQLITE_OK ) return rc;
-  rc = dlrInit(&right, DL_POSITIONS, pRight, nRight);
-  if( rc!=SQLITE_OK ){
-    dlrDestroy(&left);
-    return rc;
-  }
+  dlrInit(&left, DL_POSITIONS, pLeft, nLeft);
+  dlrInit(&right, DL_POSITIONS, pRight, nRight);
   dlwInit(&writer, iType, pOut);
 
   while( !dlrAtEnd(&left) && !dlrAtEnd(&right) ){
     if( dlrDocid(&left)<dlrDocid(&right) ){
-      rc = dlrStep(&left);
-      if( rc!=SQLITE_OK ) break;
+      dlrStep(&left);
     }else if( dlrDocid(&right)<dlrDocid(&left) ){
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      dlrStep(&right);
     }else{
-      rc = posListPhraseMerge(&left, &right, &writer);
-      if( rc!=SQLITE_OK ) break;
-      rc = dlrStep(&left);
-      if( rc!=SQLITE_OK ) break;
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      posListPhraseMerge(&left, &right, &writer);
+      dlrStep(&left);
+      dlrStep(&right);
     }
   }
 
   dlrDestroy(&left);
   dlrDestroy(&right);
   dlwDestroy(&writer);
-  return rc;
 }
 
 /* We have two DL_DOCIDS doclists:  pLeft and pRight.
 ** Write the intersection of these two doclists into pOut as a
 ** DL_DOCIDS doclist.
 */
-static int docListAndMerge(
+static void docListAndMerge(
   const char *pLeft, int nLeft,
   const char *pRight, int nRight,
   DataBuffer *pOut      /* Write the combined doclist here */
 ){
   DLReader left, right;
   DLWriter writer;
-  int rc;
 
-  if( nLeft==0 || nRight==0 ) return SQLITE_OK;
+  if( nLeft==0 || nRight==0 ) return;
 
-  rc = dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
-  if( rc!=SQLITE_OK ) return rc;
-  rc = dlrInit(&right, DL_DOCIDS, pRight, nRight);
-  if( rc!=SQLITE_OK ){
-    dlrDestroy(&left);
-    return rc;
-  }
+  dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
+  dlrInit(&right, DL_DOCIDS, pRight, nRight);
   dlwInit(&writer, DL_DOCIDS, pOut);
 
   while( !dlrAtEnd(&left) && !dlrAtEnd(&right) ){
     if( dlrDocid(&left)<dlrDocid(&right) ){
-      rc = dlrStep(&left);
-      if( rc!=SQLITE_OK ) break;
+      dlrStep(&left);
     }else if( dlrDocid(&right)<dlrDocid(&left) ){
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      dlrStep(&right);
     }else{
       dlwAdd(&writer, dlrDocid(&left));
-      rc = dlrStep(&left);
-      if( rc!=SQLITE_OK ) break;
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      dlrStep(&left);
+      dlrStep(&right);
     }
   }
 
   dlrDestroy(&left);
   dlrDestroy(&right);
   dlwDestroy(&writer);
-  return rc;
 }
 
 /* We have two DL_DOCIDS doclists:  pLeft and pRight.
 ** Write the union of these two doclists into pOut as a
 ** DL_DOCIDS doclist.
 */
-static int docListOrMerge(
+static void docListOrMerge(
   const char *pLeft, int nLeft,
   const char *pRight, int nRight,
   DataBuffer *pOut      /* Write the combined doclist here */
 ){
   DLReader left, right;
   DLWriter writer;
-  int rc;
 
   if( nLeft==0 ){
     if( nRight!=0 ) dataBufferAppend(pOut, pRight, nRight);
-    return SQLITE_OK;
+    return;
   }
   if( nRight==0 ){
     dataBufferAppend(pOut, pLeft, nLeft);
-    return SQLITE_OK;
+    return;
   }
 
-  rc = dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
-  if( rc!=SQLITE_OK ) return rc;
-  rc = dlrInit(&right, DL_DOCIDS, pRight, nRight);
-  if( rc!=SQLITE_OK ){
-    dlrDestroy(&left);
-    return rc;
-  }
+  dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
+  dlrInit(&right, DL_DOCIDS, pRight, nRight);
   dlwInit(&writer, DL_DOCIDS, pOut);
 
   while( !dlrAtEnd(&left) || !dlrAtEnd(&right) ){
     if( dlrAtEnd(&right) ){
       dlwAdd(&writer, dlrDocid(&left));
-      rc = dlrStep(&left);
-      if( rc!=SQLITE_OK ) break;
+      dlrStep(&left);
     }else if( dlrAtEnd(&left) ){
       dlwAdd(&writer, dlrDocid(&right));
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      dlrStep(&right);
     }else if( dlrDocid(&left)<dlrDocid(&right) ){
       dlwAdd(&writer, dlrDocid(&left));
-      rc = dlrStep(&left);
-      if( rc!=SQLITE_OK ) break;
+      dlrStep(&left);
     }else if( dlrDocid(&right)<dlrDocid(&left) ){
       dlwAdd(&writer, dlrDocid(&right));
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      dlrStep(&right);
     }else{
       dlwAdd(&writer, dlrDocid(&left));
-      rc = dlrStep(&left);
-      if( rc!=SQLITE_OK ) break;
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) break;
+      dlrStep(&left);
+      dlrStep(&right);
     }
   }
 
   dlrDestroy(&left);
   dlrDestroy(&right);
   dlwDestroy(&writer);
-  return rc;
 }
 
 /* We have two DL_DOCIDS doclists:  pLeft and pRight.
 ** Write into pOut as DL_DOCIDS doclist containing all documents that
 ** occur in pLeft but not in pRight.
 */
-static int docListExceptMerge(
+static void docListExceptMerge(
   const char *pLeft, int nLeft,
   const char *pRight, int nRight,
   DataBuffer *pOut      /* Write the combined doclist here */
 ){
   DLReader left, right;
   DLWriter writer;
-  int rc;
 
-  if( nLeft==0 ) return SQLITE_OK;
+  if( nLeft==0 ) return;
   if( nRight==0 ){
     dataBufferAppend(pOut, pLeft, nLeft);
-    return SQLITE_OK;
+    return;
   }
 
-  rc = dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
-  if( rc!=SQLITE_OK ) return rc;
-  rc = dlrInit(&right, DL_DOCIDS, pRight, nRight);
-  if( rc!=SQLITE_OK ){
-    dlrDestroy(&left);
-    return rc;
-  }
+  dlrInit(&left, DL_DOCIDS, pLeft, nLeft);
+  dlrInit(&right, DL_DOCIDS, pRight, nRight);
   dlwInit(&writer, DL_DOCIDS, pOut);
 
   while( !dlrAtEnd(&left) ){
     while( !dlrAtEnd(&right) && dlrDocid(&right)<dlrDocid(&left) ){
-      rc = dlrStep(&right);
-      if( rc!=SQLITE_OK ) goto err;
+      dlrStep(&right);
     }
     if( dlrAtEnd(&right) || dlrDocid(&left)<dlrDocid(&right) ){
       dlwAdd(&writer, dlrDocid(&left));
     }
-    rc = dlrStep(&left);
-    if( rc!=SQLITE_OK ) break;
+    dlrStep(&left);
   }
 
-err:
   dlrDestroy(&left);
   dlrDestroy(&right);
   dlwDestroy(&writer);
-  return rc;
 }
 
 static char *string_dup_n(const char *s, int n){
   char *str = sqlite3_malloc(n + 1);
   memcpy(str, s, n);
   str[n] = '\0';
   return str;
 }
 
 /* Duplicate a string; the caller must free() the returned string.
@@ skipping 183 matching lines @@
   /* CONTENT_EXISTS */ "select rowid from %_content limit 1",
 
   /* BLOCK_INSERT */ "insert into %_segments values (?)",
   /* BLOCK_SELECT */ "select block from %_segments where rowid = ?",
   /* BLOCK_DELETE */ "delete from %_segments where rowid between ? and ?",
   /* BLOCK_DELETE_ALL */ "delete from %_segments",
 
   /* SEGDIR_MAX_INDEX */ "select max(idx) from %_segdir where level = ?",
   /* SEGDIR_SET */ "insert into %_segdir values (?, ?, ?, ?, ?, ?)",
   /* SEGDIR_SELECT_LEVEL */
-  "select start_block, leaves_end_block, root, idx from %_segdir "
+  "select start_block, leaves_end_block, root from %_segdir "
   " where level = ? order by idx",
   /* SEGDIR_SPAN */
   "select min(start_block), max(end_block) from %_segdir "
   " where level = ? and start_block <> 0",
   /* SEGDIR_DELETE */ "delete from %_segdir where level = ?",
 
   /* NOTE(shess): The first three results of the following two
   ** statements must match.
   */
   /* SEGDIR_SELECT_SEGMENT */
@@ skipping 1578 matching lines @@
     }
   } else {  /* full-text query */
     rc = sqlite3_reset(c->pStmt);
     if( rc!=SQLITE_OK ) return rc;
 
     if( c->result.nData==0 || dlrAtEnd(&c->reader) ){
       c->eof = 1;
       return SQLITE_OK;
     }
     rc = sqlite3_bind_int64(c->pStmt, 1, dlrDocid(&c->reader));
-    if( rc!=SQLITE_OK ) return rc;
-    rc = dlrStep(&c->reader);
+    dlrStep(&c->reader);
     if( rc!=SQLITE_OK ) return rc;
     /* TODO(shess) Handle SQLITE_SCHEMA AND SQLITE_BUSY. */
     rc = sqlite3_step(c->pStmt);
     if( rc==SQLITE_ROW ){   /* the case we expect */
       c->eof = 0;
       return SQLITE_OK;
     }
-
-    /* Corrupt if the index refers to missing document. */
-    if( rc==SQLITE_DONE ) return SQLITE_CORRUPT_BKPT;
-
-    return rc;
+    /* an error occurred; abort */
+    return rc==SQLITE_DONE ? SQLITE_ERROR : rc;
   }
 }
 
 
 /* TODO(shess) If we pushed LeafReader to the top of the file, or to
 ** another file, term_select() could be pushed above
 ** docListOfTerm().
 */
 static int termSelect(fulltext_vtab *v, int iColumn,
                       const char *pTerm, int nTerm, int isPrefix,
@@ skipping 27 matching lines @@
   if( rc ) return rc;
   for(i=1; i<=pQTerm->nPhrase && left.nData>0; i++){
     dataBufferInit(&right, 0);
     rc = termSelect(v, iColumn, pQTerm[i].pTerm, pQTerm[i].nTerm,
                     pQTerm[i].isPrefix, DL_POSITIONS, &right);
     if( rc ){
       dataBufferDestroy(&left);
       return rc;
     }
     dataBufferInit(&new, 0);
-    rc = docListPhraseMerge(left.pData, left.nData, right.pData, right.nData,
-                            i<pQTerm->nPhrase ? DL_POSITIONS : DL_DOCIDS, &new);
+    docListPhraseMerge(left.pData, left.nData, right.pData, right.nData,
+                       i<pQTerm->nPhrase ? DL_POSITIONS : DL_DOCIDS, &new);
     dataBufferDestroy(&left);
     dataBufferDestroy(&right);
-    if( rc!=SQLITE_OK ){
-      dataBufferDestroy(&new);
-      return rc;
-    }
     left = new;
   }
   *pResult = left;
-  return rc;
+  return SQLITE_OK;
 }
 
 /* Add a new term pTerm[0..nTerm-1] to the query *q.
 */
 static void queryAdd(Query *q, const char *pTerm, int nTerm){
   QueryTerm *t;
   ++q->nTerms;
   q->pTerms = sqlite3_realloc(q->pTerms, q->nTerms * sizeof(q->pTerms[0]));
   if( q->pTerms==0 ){
     q->nTerms = 0;
@@ skipping 46 matching lines @@
   sqlite3_tokenizer *pTokenizer,          /* The tokenizer to use */
   const char *pSegment, int nSegment,     /* Query expression being parsed */
   int inPhrase,                           /* True if within "..." */
   Query *pQuery                           /* Append results here */
 ){
   const sqlite3_tokenizer_module *pModule = pTokenizer->pModule;
   sqlite3_tokenizer_cursor *pCursor;
   int firstIndex = pQuery->nTerms;
   int iCol;
   int nTerm = 1;
-  int iEndLast = -1;
   
   int rc = pModule->xOpen(pTokenizer, pSegment, nSegment, &pCursor);
   if( rc!=SQLITE_OK ) return rc;
   pCursor->pTokenizer = pTokenizer;
 
   while( 1 ){
     const char *pToken;
     int nToken, iBegin, iEnd, iPos;
 
     rc = pModule->xNext(pCursor,
                         &pToken, &nToken,
                         &iBegin, &iEnd, &iPos);
     if( rc!=SQLITE_OK ) break;
     if( !inPhrase &&
         pSegment[iEnd]==':' &&
          (iCol = checkColumnSpecifier(pQuery->pFts, pToken, nToken))>=0 ){
       pQuery->nextColumn = iCol;
       continue;
     }
     if( !inPhrase && pQuery->nTerms>0 && nToken==2
          && pSegment[iBegin]=='O' && pSegment[iBegin+1]=='R' ){
       pQuery->nextIsOr = 1;
       continue;
     }
-
-    /*
-     * The ICU tokenizer considers '*' a break character, so the code below
-     * sets isPrefix correctly, but since that code doesn't eat the '*', the
-     * ICU tokenizer returns it as the next token.  So eat it here until a
-     * better solution presents itself.
-     */
-    if( pQuery->nTerms>0 && nToken==1 && pSegment[iBegin]=='*' &&
-        iEndLast==iBegin){
-      pQuery->pTerms[pQuery->nTerms-1].isPrefix = 1;
-      continue;
-    }
-    iEndLast = iEnd;
-
     queryAdd(pQuery, pToken, nToken);
     if( !inPhrase && iBegin>0 && pSegment[iBegin-1]=='-' ){
       pQuery->pTerms[pQuery->nTerms-1].isNot = 1;
     }
     if( iEnd<nSegment && pSegment[iEnd]=='*' ){
       pQuery->pTerms[pQuery->nTerms-1].isPrefix = 1;
     }
     pQuery->pTerms[pQuery->nTerms-1].iPhrase = nTerm;
     if( inPhrase ){
       nTerm++;
@@ skipping 119 matching lines @@
     while( iNext<pQuery->nTerms && aTerm[iNext].isOr ){
       rc = docListOfTerm(v, aTerm[iNext].iColumn, &aTerm[iNext], &or);
       iNext += aTerm[iNext].nPhrase + 1;
       if( rc ){
         if( i!=nNot ) dataBufferDestroy(&left);
         dataBufferDestroy(&right);
         queryClear(pQuery);
         return rc;
       }
       dataBufferInit(&new, 0);
-      rc = docListOrMerge(right.pData, right.nData, or.pData, or.nData, &new);
+      docListOrMerge(right.pData, right.nData, or.pData, or.nData, &new);
       dataBufferDestroy(&right);
       dataBufferDestroy(&or);
-      if( rc!=SQLITE_OK ){
-        if( i!=nNot ) dataBufferDestroy(&left);
-        queryClear(pQuery);
-        dataBufferDestroy(&new);
-        return rc;
-      }
       right = new;
     }
     if( i==nNot ){           /* first term processed. */
       left = right;
     }else{
       dataBufferInit(&new, 0);
-      rc = docListAndMerge(left.pData, left.nData,
-                           right.pData, right.nData, &new);
+      docListAndMerge(left.pData, left.nData, right.pData, right.nData, &new);
       dataBufferDestroy(&right);
       dataBufferDestroy(&left);
-      if( rc!=SQLITE_OK ){
-        queryClear(pQuery);
-        dataBufferDestroy(&new);
-        return rc;
-      }
       left = new;
     }
   }
 
   if( nNot==pQuery->nTerms ){
     /* We do not yet know how to handle a query of only NOT terms */
     return SQLITE_ERROR;
   }
 
   /* Do the EXCEPT terms */
   for(i=0; i<pQuery->nTerms;  i += aTerm[i].nPhrase + 1){
     if( !aTerm[i].isNot ) continue;
     rc = docListOfTerm(v, aTerm[i].iColumn, &aTerm[i], &right);
     if( rc ){
       queryClear(pQuery);
       dataBufferDestroy(&left);
       return rc;
     }
     dataBufferInit(&new, 0);
-    rc = docListExceptMerge(left.pData, left.nData,
-                            right.pData, right.nData, &new);
+    docListExceptMerge(left.pData, left.nData, right.pData, right.nData, &new);
     dataBufferDestroy(&right);
     dataBufferDestroy(&left);
-    if( rc!=SQLITE_OK ){
-      queryClear(pQuery);
-      dataBufferDestroy(&new);
-      return rc;
-    }
     left = new;
   }
 
   *pResult = left;
   return rc;
 }
 
 /*
 ** This is the xFilter interface for the virtual table.  See
 ** the virtual table xFilter method documentation for additional
@@ skipping 73 matching lines @@
       if( c->result.nData!=0 ){
         /* This case happens if the same cursor is used repeatedly. */
         dlrDestroy(&c->reader);
         dataBufferReset(&c->result);
       }else{
         dataBufferInit(&c->result, 0);
       }
       rc = fulltextQuery(v, idxNum-QUERY_FULLTEXT, zQuery, -1, &c->result, &c->q);
       if( rc!=SQLITE_OK ) return rc;
       if( c->result.nData!=0 ){
-        rc = dlrInit(&c->reader, DL_DOCIDS, c->result.pData, c->result.nData);
-        if( rc!=SQLITE_OK ) return rc;
+        dlrInit(&c->reader, DL_DOCIDS, c->result.pData, c->result.nData);
       }
       break;
     }
   }
 
   return fulltextNext(pCursor);
 }
 
 /* This is the xEof method of the virtual table.  The SQLite core
 ** calls this routine to find out if it has reached the end of
@@ skipping 480 matching lines @@
   DataBuffer term;          /* previous term, for decoding term delta. */
 
   sqlite_int64 iBlockid;
 } InteriorReader;
 
 static void interiorReaderDestroy(InteriorReader *pReader){
   dataBufferDestroy(&pReader->term);
   SCRAMBLE(pReader);
 }
 
-static int interiorReaderInit(const char *pData, int nData,
-                              InteriorReader *pReader){
+/* TODO(shess) The assertions are great, but what if we're in NDEBUG
+** and the blob is empty or otherwise contains suspect data?
+*/
+static void interiorReaderInit(const char *pData, int nData,
+                               InteriorReader *pReader){
   int n, nTerm;
 
-  /* These conditions are checked and met by the callers. */
+  /* Require at least the leading flag byte */
   assert( nData>0 );
   assert( pData[0]!='\0' );
 
   CLEAR(pReader);
 
   /* Decode the base blockid, and set the cursor to the first term. */
-  n = getVarintSafe(pData+1, &pReader->iBlockid, nData-1);
-  if( !n ) return SQLITE_CORRUPT_BKPT;
+  n = getVarint(pData+1, &pReader->iBlockid);
+  assert( 1+n<=nData );
   pReader->pData = pData+1+n;
   pReader->nData = nData-(1+n);
 
   /* A single-child interior node (such as when a leaf node was too
   ** large for the segment directory) won't have any terms.
   ** Otherwise, decode the first term.
   */
   if( pReader->nData==0 ){
     dataBufferInit(&pReader->term, 0);
   }else{
-    n = getVarint32Safe(pReader->pData, &nTerm, pReader->nData);
-    if( !n || nTerm<0 || nTerm>pReader->nData-n) return SQLITE_CORRUPT_BKPT;
+    n = getVarint32(pReader->pData, &nTerm);
     dataBufferInit(&pReader->term, nTerm);
     dataBufferReplace(&pReader->term, pReader->pData+n, nTerm);
+    assert( n+nTerm<=pReader->nData );
     pReader->pData += n+nTerm;
     pReader->nData -= n+nTerm;
   }
-  return SQLITE_OK;
 }
 
 static int interiorReaderAtEnd(InteriorReader *pReader){
-  return pReader->term.nData<=0;
+  return pReader->term.nData==0;
 }
 
 static sqlite_int64 interiorReaderCurrentBlockid(InteriorReader *pReader){
   return pReader->iBlockid;
 }
 
 static int interiorReaderTermBytes(InteriorReader *pReader){
   assert( !interiorReaderAtEnd(pReader) );
   return pReader->term.nData;
 }
 static const char *interiorReaderTerm(InteriorReader *pReader){
   assert( !interiorReaderAtEnd(pReader) );
   return pReader->term.pData;
 }
 
 /* Step forward to the next term in the node. */
-static int interiorReaderStep(InteriorReader *pReader){
+static void interiorReaderStep(InteriorReader *pReader){
   assert( !interiorReaderAtEnd(pReader) );
 
   /* If the last term has been read, signal eof, else construct the
   ** next term.
   */
   if( pReader->nData==0 ){
     dataBufferReset(&pReader->term);
   }else{
     int n, nPrefix, nSuffix;
 
-    n = getVarint32Safe(pReader->pData, &nPrefix, pReader->nData);
-    if( !n ) return SQLITE_CORRUPT_BKPT;
-    pReader->nData -= n;
-    pReader->pData += n;
-    n = getVarint32Safe(pReader->pData, &nSuffix, pReader->nData);
-    if( !n ) return SQLITE_CORRUPT_BKPT;
-    pReader->nData -= n;
-    pReader->pData += n;
-    if( nSuffix<0 || nSuffix>pReader->nData ) return SQLITE_CORRUPT_BKPT;
-    if( nPrefix<0 || nPrefix>pReader->term.nData ) return SQLITE_CORRUPT_BKPT;
+    n = getVarint32(pReader->pData, &nPrefix);
+    n += getVarint32(pReader->pData+n, &nSuffix);
 
     /* Truncate the current term and append suffix data. */
     pReader->term.nData = nPrefix;
-    dataBufferAppend(&pReader->term, pReader->pData, nSuffix);
+    dataBufferAppend(&pReader->term, pReader->pData+n, nSuffix);
 
-    pReader->pData += nSuffix;
-    pReader->nData -= nSuffix;
+    assert( n+nSuffix<=pReader->nData );
+    pReader->pData += n+nSuffix;
+    pReader->nData -= n+nSuffix;
   }
   pReader->iBlockid++;
-  return SQLITE_OK;
 }
 
 /* Compare the current term to pTerm[nTerm], returning strcmp-style
 ** results.  If isPrefix, equality means equal through nTerm bytes.
 */
 static int interiorReaderTermCmp(InteriorReader *pReader,
                                  const char *pTerm, int nTerm, int isPrefix){
   const char *pReaderTerm = interiorReaderTerm(pReader);
   int nReaderTerm = interiorReaderTermBytes(pReader);
   int c, n = nReaderTerm<nTerm ? nReaderTerm : nTerm;
@@ skipping 351 matching lines @@
 
   /* Estimate the length of the merged doclist so we can leave space
   ** to encode it.
   */
   for(i=0, nData=0; i<nReaders; i++){
     nData += dlrAllDataBytes(&pReaders[i]);
   }
   n = putVarint(c, nData);
   dataBufferAppend(&pWriter->data, c, n);
 
-  rc = docListMerge(&pWriter->data, pReaders, nReaders);
-  if( rc!= SQLITE_OK ) return rc;
+  docListMerge(&pWriter->data, pReaders, nReaders);
   ASSERT_VALID_DOCLIST(DL_DEFAULT,
                        pWriter->data.pData+iDoclistData+n,
                        pWriter->data.nData-iDoclistData-n, NULL);
 
   /* The actual amount of doclist data at this point could be smaller
   ** than the length we encoded.  Additionally, the space required to
   ** encode this length could be smaller.  For small doclists, this is
   ** not a big deal, we can just use memmove() to adjust things.
   */
   nActualData = pWriter->data.nData-(iDoclistData+n);
@@ skipping 89 matching lines @@
 */
 /* TODO(shess) Revise writeZeroSegment() so that doclists are
 ** constructed directly in pWriter->data.
 */
 static int leafWriterStep(fulltext_vtab *v, LeafWriter *pWriter,
                           const char *pTerm, int nTerm,
                           const char *pData, int nData){
   int rc;
   DLReader reader;
 
-  rc = dlrInit(&reader, DL_DEFAULT, pData, nData);
-  if( rc!=SQLITE_OK ) return rc;
+  dlrInit(&reader, DL_DEFAULT, pData, nData);
   rc = leafWriterStepMerge(v, pWriter, pTerm, nTerm, &reader, 1);
   dlrDestroy(&reader);
 
   return rc;
 }
 
 
 /****************************************************************/
 /* LeafReader is used to iterate over an individual leaf node. */
 typedef struct LeafReader {
@@ skipping 24 matching lines @@
 /* Access the doclist data for the current term. */
 static int leafReaderDataBytes(LeafReader *pReader){
   int nData;
   assert( pReader->term.nData>0 );
   getVarint32(pReader->pData, &nData);
   return nData;
 }
 static const char *leafReaderData(LeafReader *pReader){
   int n, nData;
   assert( pReader->term.nData>0 );
-  n = getVarint32Safe(pReader->pData, &nData, pReader->nData);
-  if( !n || nData>pReader->nData-n ) return NULL;
+  n = getVarint32(pReader->pData, &nData);
   return pReader->pData+n;
 }
 
-static int leafReaderInit(const char *pData, int nData, LeafReader *pReader){
+static void leafReaderInit(const char *pData, int nData,
+                           LeafReader *pReader){
   int nTerm, n;
 
-  /* All callers check this precondition. */
   assert( nData>0 );
   assert( pData[0]=='\0' );
 
   CLEAR(pReader);
 
   /* Read the first term, skipping the header byte. */
-  n = getVarint32Safe(pData+1, &nTerm, nData-1);
-  if( !n || nTerm<0 || nTerm>nData-1-n ) return SQLITE_CORRUPT_BKPT;
+  n = getVarint32(pData+1, &nTerm);
   dataBufferInit(&pReader->term, nTerm);
   dataBufferReplace(&pReader->term, pData+1+n, nTerm);
 
   /* Position after the first term. */
+  assert( 1+n+nTerm<nData );
   pReader->pData = pData+1+n+nTerm;
   pReader->nData = nData-1-n-nTerm;
-  return SQLITE_OK;
 }
 
 /* Step the reader forward to the next term. */
-static int leafReaderStep(LeafReader *pReader){
+static void leafReaderStep(LeafReader *pReader){
   int n, nData, nPrefix, nSuffix;
   assert( !leafReaderAtEnd(pReader) );
 
   /* Skip previous entry's data block. */
-  n = getVarint32Safe(pReader->pData, &nData, pReader->nData);
-  if( !n || nData<0 || nData>pReader->nData-n ) return SQLITE_CORRUPT_BKPT;
+  n = getVarint32(pReader->pData, &nData);
+  assert( n+nData<=pReader->nData );
   pReader->pData += n+nData;
   pReader->nData -= n+nData;
 
   if( !leafReaderAtEnd(pReader) ){
     /* Construct the new term using a prefix from the old term plus a
     ** suffix from the leaf data.
     */
-    n = getVarint32Safe(pReader->pData, &nPrefix, pReader->nData);
-    if( !n ) return SQLITE_CORRUPT_BKPT;
-    pReader->nData -= n;
-    pReader->pData += n;
-    n = getVarint32Safe(pReader->pData, &nSuffix, pReader->nData);
-    if( !n ) return SQLITE_CORRUPT_BKPT;
-    pReader->nData -= n;
-    pReader->pData += n;
-    if( nSuffix<0 || nSuffix>pReader->nData ) return SQLITE_CORRUPT_BKPT;
-    if( nPrefix<0 || nPrefix>pReader->term.nData ) return SQLITE_CORRUPT_BKPT;
+    n = getVarint32(pReader->pData, &nPrefix);
+    n += getVarint32(pReader->pData+n, &nSuffix);
+    assert( n+nSuffix<pReader->nData );
     pReader->term.nData = nPrefix;
-    dataBufferAppend(&pReader->term, pReader->pData, nSuffix);
+    dataBufferAppend(&pReader->term, pReader->pData+n, nSuffix);
 
-    pReader->pData += nSuffix;
-    pReader->nData -= nSuffix;
+    pReader->pData += n+nSuffix;
+    pReader->nData -= n+nSuffix;
   }
-  return SQLITE_OK;
 }
 
 /* strcmp-style comparison of pReader's current term against pTerm.
 ** If isPrefix, equality means equal through nTerm bytes.
 */
 static int leafReaderTermCmp(LeafReader *pReader,
                              const char *pTerm, int nTerm, int isPrefix){
   int c, n = pReader->term.nData<nTerm ? pReader->term.nData : nTerm;
   if( n==0 ){
     if( pReader->term.nData>0 ) return -1;
@@ skipping 72 matching lines @@
   }
   leafReaderDestroy(&pReader->leafReader);
   dataBufferDestroy(&pReader->rootData);
   SCRAMBLE(pReader);
 }
 
 /* Initialize pReader with the given root data (if iStartBlockid==0
 ** the leaf data was entirely contained in the root), or from the
 ** stream of blocks between iStartBlockid and iEndBlockid, inclusive.
 */
-/* TODO(shess): Figure out a means of indicating how many leaves are
-** expected, for purposes of detecting corruption.
-*/
 static int leavesReaderInit(fulltext_vtab *v,
                             int idx,
                             sqlite_int64 iStartBlockid,
                             sqlite_int64 iEndBlockid,
                             const char *pRootData, int nRootData,
                             LeavesReader *pReader){
   CLEAR(pReader);
   pReader->idx = idx;
 
   dataBufferInit(&pReader->rootData, 0);
   if( iStartBlockid==0 ){
-    int rc;
-    /* Corrupt if this can't be a leaf node. */
-    if( pRootData==NULL || nRootData<1 || pRootData[0]!='\0' ){
-      return SQLITE_CORRUPT_BKPT;
-    }
     /* Entire leaf level fit in root data. */
     dataBufferReplace(&pReader->rootData, pRootData, nRootData);
-    rc = leafReaderInit(pReader->rootData.pData, pReader->rootData.nData,
-                        &pReader->leafReader);
-    if( rc!=SQLITE_OK ){
-      dataBufferDestroy(&pReader->rootData);
-      return rc;
-    }
+    leafReaderInit(pReader->rootData.pData, pReader->rootData.nData,
+                   &pReader->leafReader);
   }else{
     sqlite3_stmt *s;
     int rc = sql_get_leaf_statement(v, idx, &s);
     if( rc!=SQLITE_OK ) return rc;
 
     rc = sqlite3_bind_int64(s, 1, iStartBlockid);
-    if( rc!=SQLITE_OK ) goto err;
+    if( rc!=SQLITE_OK ) return rc;
 
     rc = sqlite3_bind_int64(s, 2, iEndBlockid);
-    if( rc!=SQLITE_OK ) goto err;
+    if( rc!=SQLITE_OK ) return rc;
 
     rc = sqlite3_step(s);
-
-    /* Corrupt if interior node referenced missing leaf node. */
     if( rc==SQLITE_DONE ){
-      rc = SQLITE_CORRUPT_BKPT;
-      goto err;
+      pReader->eof = 1;
+      return SQLITE_OK;
     }
-
-    if( rc!=SQLITE_ROW ) goto err;
-    rc = SQLITE_OK;
-
-    /* Corrupt if leaf data isn't a blob. */
-    if( sqlite3_column_type(s, 0)!=SQLITE_BLOB ){
-      rc = SQLITE_CORRUPT_BKPT;
-    }else{
-      const char *pLeafData = sqlite3_column_blob(s, 0);
-      int nLeafData = sqlite3_column_bytes(s, 0);
-
-      /* Corrupt if this can't be a leaf node. */
-      if( pLeafData==NULL || nLeafData<1 || pLeafData[0]!='\0' ){
-        rc = SQLITE_CORRUPT_BKPT;
-      }else{
-        rc = leafReaderInit(pLeafData, nLeafData, &pReader->leafReader);
-      }
-    }
-
- err:
-    if( rc!=SQLITE_OK ){
-      if( idx==-1 ){
-        sqlite3_finalize(s);
-      }else{
-        sqlite3_reset(s);
-      }
-      return rc;
-    }
+    if( rc!=SQLITE_ROW ) return rc;
 
     pReader->pStmt = s;
+    leafReaderInit(sqlite3_column_blob(pReader->pStmt, 0),
+                   sqlite3_column_bytes(pReader->pStmt, 0),
+                   &pReader->leafReader);
   }
   return SQLITE_OK;
 }
 
 /* Step the current leaf forward to the next term.  If we reach the
 ** end of the current leaf, step forward to the next leaf block.
 */
 static int leavesReaderStep(fulltext_vtab *v, LeavesReader *pReader){
-  int rc;
   assert( !leavesReaderAtEnd(pReader) );
-  rc = leafReaderStep(&pReader->leafReader);
-  if( rc!=SQLITE_OK ) return rc;
+  leafReaderStep(&pReader->leafReader);
 
   if( leafReaderAtEnd(&pReader->leafReader) ){
+    int rc;
     if( pReader->rootData.pData ){
       pReader->eof = 1;
       return SQLITE_OK;
     }
     rc = sqlite3_step(pReader->pStmt);
     if( rc!=SQLITE_ROW ){
       pReader->eof = 1;
       return rc==SQLITE_DONE ? SQLITE_OK : rc;
     }
-
-    /* Corrupt if leaf data isn't a blob. */
-    if( sqlite3_column_type(pReader->pStmt, 0)!=SQLITE_BLOB ){
-      return SQLITE_CORRUPT_BKPT;
-    }else{
-      LeafReader tmp;
-      const char *pLeafData = sqlite3_column_blob(pReader->pStmt, 0);
-      int nLeafData = sqlite3_column_bytes(pReader->pStmt, 0);
-
-      /* Corrupt if this can't be a leaf node. */
-      if( pLeafData==NULL || nLeafData<1 || pLeafData[0]!='\0' ){
-        return SQLITE_CORRUPT_BKPT;
-      }
-
-      rc = leafReaderInit(pLeafData, nLeafData, &tmp);
-      if( rc!=SQLITE_OK ) return rc;
-      leafReaderDestroy(&pReader->leafReader);
-      pReader->leafReader = tmp;
-    }
+    leafReaderDestroy(&pReader->leafReader);
+    leafReaderInit(sqlite3_column_blob(pReader->pStmt, 0),
+                   sqlite3_column_bytes(pReader->pStmt, 0),
+                   &pReader->leafReader);
   }
   return SQLITE_OK;
 }
 
 /* Order LeavesReaders by their term, ignoring idx.  Readers at eof
 ** always sort to the end.
 */
 static int leavesReaderTermCmp(LeavesReader *lr1, LeavesReader *lr2){
   if( leavesReaderAtEnd(lr1) ){
     if( leavesReaderAtEnd(lr2) ) return 0;
@@ skipping 40 matching lines @@
 
   rc = sqlite3_bind_int(s, 1, iLevel);
   if( rc!=SQLITE_OK ) return rc;
 
   i = 0;
   while( (rc = sqlite3_step(s))==SQLITE_ROW ){
     sqlite_int64 iStart = sqlite3_column_int64(s, 0);
     sqlite_int64 iEnd = sqlite3_column_int64(s, 1);
     const char *pRootData = sqlite3_column_blob(s, 2);
     int nRootData = sqlite3_column_bytes(s, 2);
-    sqlite_int64 iIndex = sqlite3_column_int64(s, 3);
 
-    /* Corrupt if we get back different types than we stored. */
-    /* Also corrupt if the index is not sequential starting at 0. */
-    if( sqlite3_column_type(s, 0)!=SQLITE_INTEGER ||
-        sqlite3_column_type(s, 1)!=SQLITE_INTEGER ||
-        sqlite3_column_type(s, 2)!=SQLITE_BLOB ||
-        i!=iIndex ||
-        i>=MERGE_COUNT ){
-      rc = SQLITE_CORRUPT_BKPT;
-      break;
-    }
-
+    assert( i<MERGE_COUNT );
     rc = leavesReaderInit(v, i, iStart, iEnd, pRootData, nRootData,
                           &pReaders[i]);
     if( rc!=SQLITE_OK ) break;
 
     i++;
   }
   if( rc!=SQLITE_DONE ){
     while( i-->0 ){
       leavesReaderDestroy(&pReaders[i]);
     }
-    sqlite3_reset(s);          /* So we don't leave a lock. */
     return rc;
   }
 
   *piReaders = i;
 
   /* Leave our results sorted by term, then age. */
   while( i-- ){
     leavesReaderReorder(pReaders+i, *piReaders-i);
   }
   return SQLITE_OK;
 }
 
 /* Merge doclists from pReaders[nReaders] into a single doclist, which
 ** is written to pWriter.  Assumes pReaders is ordered oldest to
 ** newest.
 */
 /* TODO(shess) Consider putting this inline in segmentMerge(). */
 static int leavesReadersMerge(fulltext_vtab *v,
                               LeavesReader *pReaders, int nReaders,
                               LeafWriter *pWriter){
   DLReader dlReaders[MERGE_COUNT];
   const char *pTerm = leavesReaderTerm(pReaders);
   int i, nTerm = leavesReaderTermBytes(pReaders);
-  int rc;
 
   assert( nReaders<=MERGE_COUNT );
 
   for(i=0; i<nReaders; i++){
-    const char *pData = leavesReaderData(pReaders+i);
-    if( pData==NULL ){
-      rc = SQLITE_CORRUPT_BKPT;
-      break;
-    }
-    rc = dlrInit(&dlReaders[i], DL_DEFAULT,
-                 pData,
-                 leavesReaderDataBytes(pReaders+i));
-    if( rc!=SQLITE_OK ) break;
-  }
-  if( rc!=SQLITE_OK ){
-    while( i-->0 ){
-      dlrDestroy(&dlReaders[i]);
-    }
-    return rc;
+    dlrInit(&dlReaders[i], DL_DEFAULT,
+            leavesReaderData(pReaders+i),
+            leavesReaderDataBytes(pReaders+i));
   }
 
   return leafWriterStepMerge(v, pWriter, pTerm, nTerm, dlReaders, nReaders);
 }
 
 /* Forward ref due to mutual recursion with segdirNextIndex(). */
 static int segmentMerge(fulltext_vtab *v, int iLevel);
 
 /* Put the next available index at iLevel into *pidx.  If iLevel
 ** already has MERGE_COUNT segments, they are merged to a higher
@@ skipping 33 matching lines @@
   if( rc!=SQLITE_OK ) return rc;
 
   /* TODO(shess) This assumes that we'll always see exactly
   ** MERGE_COUNT segments to merge at a given level.  That will be
   ** broken if we allow the developer to request preemptive or
   ** deferred merging.
   */
   memset(&lrs, '\0', sizeof(lrs));
   rc = leavesReadersInit(v, iLevel, lrs, &i);
   if( rc!=SQLITE_OK ) return rc;
+  assert( i==MERGE_COUNT );
 
   leafWriterInit(iLevel+1, idx, &writer);
 
-  if( i!=MERGE_COUNT ){
-    rc = SQLITE_CORRUPT_BKPT;
-    goto err;
-  }
-
   /* Since leavesReaderReorder() pushes readers at eof to the end,
   ** when the first reader is empty, all will be empty.
   */
   while( !leavesReaderAtEnd(lrs) ){
     /* Figure out how many readers share their next term. */
     for(i=1; i<MERGE_COUNT && !leavesReaderAtEnd(lrs+i); i++){
       if( 0!=leavesReaderTermCmp(lrs, lrs+i) ) break;
     }
 
     rc = leavesReadersMerge(v, lrs, i, &writer);
@@ skipping 22 matching lines @@
 
  err:
   for(i=0; i<MERGE_COUNT; i++){
     leavesReaderDestroy(&lrs[i]);
   }
   leafWriterDestroy(&writer);
   return rc;
 }
 
 /* Accumulate the union of *acc and *pData into *acc. */
-static int docListAccumulateUnion(DataBuffer *acc,
-                                  const char *pData, int nData) {
+static void docListAccumulateUnion(DataBuffer *acc,
+                                   const char *pData, int nData) {
   DataBuffer tmp = *acc;
-  int rc;
   dataBufferInit(acc, tmp.nData+nData);
-  rc = docListUnion(tmp.pData, tmp.nData, pData, nData, acc);
+  docListUnion(tmp.pData, tmp.nData, pData, nData, acc);
   dataBufferDestroy(&tmp);
-  return rc;
 }
 
 /* TODO(shess) It might be interesting to explore different merge
 ** strategies, here.  For instance, since this is a sorted merge, we
 ** could easily merge many doclists in parallel.  With some
 ** comprehension of the storage format, we could merge all of the
 ** doclists within a leaf node directly from the leaf node's storage.
 ** It may be worthwhile to merge smaller doclists before larger
 ** doclists, since they can be traversed more quickly - but the
 ** results may have less overlap, making them more expensive in a
@@ skipping 21 matching lines @@
   for(rc=SQLITE_OK; rc==SQLITE_OK && !leavesReaderAtEnd(pReader);
       rc=leavesReaderStep(v, pReader)){
     /* TODO(shess) Really want leavesReaderTermCmp(), but that name is
     ** already taken to compare the terms of two LeavesReaders.  Think
     ** on a better name.  [Meanwhile, break encapsulation rather than
     ** use a confusing name.]
     */
     int c = leafReaderTermCmp(&pReader->leafReader, pTerm, nTerm, isPrefix);
     if( c>0 ) break;      /* Past any possible matches. */
     if( c==0 ){
-      int iBuffer, nData;
       const char *pData = leavesReaderData(pReader);
-      if( pData==NULL ){
-        rc = SQLITE_CORRUPT_BKPT;
-        break;
-      }
-      nData = leavesReaderDataBytes(pReader);
+      int iBuffer, nData = leavesReaderDataBytes(pReader);
 
       /* Find the first empty buffer. */
       for(iBuffer=0; iBuffer<nBuffers; ++iBuffer){
         if( 0==pBuffers[iBuffer].nData ) break;
       }
 
       /* Out of buffers, add an empty one. */
       if( iBuffer==nBuffers ){
         if( nBuffers==nMaxBuffers ){
           DataBuffer *p;
@@ skipping 25 matching lines @@
         dataBufferReplace(&(pBuffers[0]), pData, nData);
       }else{
         /* pAcc is the empty buffer the merged data will end up in. */
         DataBuffer *pAcc = &(pBuffers[iBuffer]);
         DataBuffer *p = &(pBuffers[0]);
 
         /* Handle position 0 specially to avoid need to prime pAcc
         ** with pData/nData.
         */
         dataBufferSwap(p, pAcc);
-        rc = docListAccumulateUnion(pAcc, pData, nData);
-        if( rc!=SQLITE_OK ) goto err;
+        docListAccumulateUnion(pAcc, pData, nData);
 
         /* Accumulate remaining doclists into pAcc. */
         for(++p; p<pAcc; ++p){
-          rc = docListAccumulateUnion(pAcc, p->pData, p->nData);
-          if( rc!=SQLITE_OK ) goto err;
+          docListAccumulateUnion(pAcc, p->pData, p->nData);
 
           /* dataBufferReset() could allow a large doclist to blow up
           ** our memory requirements.
           */
           if( p->nCapacity<1024 ){
             dataBufferReset(p);
           }else{
             dataBufferDestroy(p);
             dataBufferInit(p, 0);
           }
         }
       }
     }
   }
 
   /* Union all the doclists together into *out. */
   /* TODO(shess) What if *out is big?  Sigh. */
   if( rc==SQLITE_OK && nBuffers>0 ){
     int iBuffer;
     for(iBuffer=0; iBuffer<nBuffers; ++iBuffer){
       if( pBuffers[iBuffer].nData>0 ){
         if( out->nData==0 ){
           dataBufferSwap(out, &(pBuffers[iBuffer]));
         }else{
-          rc = docListAccumulateUnion(out, pBuffers[iBuffer].pData,
-                                      pBuffers[iBuffer].nData);
-          if( rc!=SQLITE_OK ) break;
+          docListAccumulateUnion(out, pBuffers[iBuffer].pData,
+                                 pBuffers[iBuffer].nData);
         }
       }
     }
   }
 
-err:
   while( nBuffers-- ){
     dataBufferDestroy(&(pBuffers[nBuffers]));
   }
   if( pBuffers!=NULL ) sqlite3_free(pBuffers);
 
   return rc;
 }
 
 /* Call loadSegmentLeavesInt() with pData/nData as input. */
 static int loadSegmentLeaf(fulltext_vtab *v, const char *pData, int nData,
@@ skipping 38 matching lines @@
 ** nodes which could include pTerm/nTerm/isPrefix.  Note that the
 ** interior node terms logically come between the blocks, so there is
 ** one more blockid than there are terms (that block contains terms >=
 ** the last interior-node term).
 */
 /* TODO(shess) The calling code may already know that the end child is
 ** not worth calculating, because the end may be in a later sibling
 ** node.  Consider whether breaking symmetry is worthwhile.  I suspect
 ** it is not worthwhile.
 */
-static int getChildrenContaining(const char *pData, int nData,
-                                 const char *pTerm, int nTerm, int isPrefix,
-                                 sqlite_int64 *piStartChild,
-                                 sqlite_int64 *piEndChild){
+static void getChildrenContaining(const char *pData, int nData,
+                                  const char *pTerm, int nTerm, int isPrefix,
+                                  sqlite_int64 *piStartChild,
+                                  sqlite_int64 *piEndChild){
   InteriorReader reader;
-  int rc;
 
   assert( nData>1 );
   assert( *pData!='\0' );
-  rc = interiorReaderInit(pData, nData, &reader);
-  if( rc!=SQLITE_OK ) return rc;
+  interiorReaderInit(pData, nData, &reader);
 
   /* Scan for the first child which could contain pTerm/nTerm. */
   while( !interiorReaderAtEnd(&reader) ){
     if( interiorReaderTermCmp(&reader, pTerm, nTerm, 0)>0 ) break;
-    rc = interiorReaderStep(&reader);
-    if( rc!=SQLITE_OK ){
-      interiorReaderDestroy(&reader);
-      return rc;
-    }
+    interiorReaderStep(&reader);
   }
   *piStartChild = interiorReaderCurrentBlockid(&reader);
 
   /* Keep scanning to find a term greater than our term, using prefix
   ** comparison if indicated.  If isPrefix is false, this will be the
   ** same blockid as the starting block.
   */
   while( !interiorReaderAtEnd(&reader) ){
     if( interiorReaderTermCmp(&reader, pTerm, nTerm, isPrefix)>0 ) break;
-    rc = interiorReaderStep(&reader);
-    if( rc!=SQLITE_OK ){
-      interiorReaderDestroy(&reader);
-      return rc;
-    }
+    interiorReaderStep(&reader);
   }
   *piEndChild = interiorReaderCurrentBlockid(&reader);
 
   interiorReaderDestroy(&reader);
 
   /* Children must ascend, and if !prefix, both must be the same. */
   assert( *piEndChild>=*piStartChild );
   assert( isPrefix || *piStartChild==*piEndChild );
-  return rc;
 }
 
 /* Read block at iBlockid and pass it with other params to
 ** getChildrenContaining().
 */
 static int loadAndGetChildrenContaining(
   fulltext_vtab *v,
   sqlite_int64 iBlockid,
   const char *pTerm, int nTerm, int isPrefix,
   sqlite_int64 *piStartChild, sqlite_int64 *piEndChild
 ){
   sqlite3_stmt *s = NULL;
   int rc;
 
   assert( iBlockid!=0 );
   assert( pTerm!=NULL );
   assert( nTerm!=0 );        /* TODO(shess) Why not allow this? */
   assert( piStartChild!=NULL );
   assert( piEndChild!=NULL );
 
   rc = sql_get_statement(v, BLOCK_SELECT_STMT, &s);
   if( rc!=SQLITE_OK ) return rc;
 
   rc = sqlite3_bind_int64(s, 1, iBlockid);
   if( rc!=SQLITE_OK ) return rc;
 
   rc = sqlite3_step(s);
-  /* Corrupt if interior node references missing child node. */
-  if( rc==SQLITE_DONE ) return SQLITE_CORRUPT_BKPT;
+  if( rc==SQLITE_DONE ) return SQLITE_ERROR;
   if( rc!=SQLITE_ROW ) return rc;
 
-  /* Corrupt if child node isn't a blob. */
-  if( sqlite3_column_type(s, 0)!=SQLITE_BLOB ){
-    sqlite3_reset(s);         /* So we don't leave a lock. */
-    return SQLITE_CORRUPT_BKPT;
-  }else{
-    const char *pData = sqlite3_column_blob(s, 0);
-    int nData = sqlite3_column_bytes(s, 0);
-
-    /* Corrupt if child is not a valid interior node. */
-    if( pData==NULL || nData<1 || pData[0]=='\0' ){
-      sqlite3_reset(s);         /* So we don't leave a lock. */
-      return SQLITE_CORRUPT_BKPT;
-    }
-
-    rc = getChildrenContaining(pData, nData, pTerm, nTerm,
-                               isPrefix, piStartChild, piEndChild);
-    if( rc!=SQLITE_OK ){
-      sqlite3_reset(s);
-      return rc;
-    }
-  }
+  getChildrenContaining(sqlite3_column_blob(s, 0), sqlite3_column_bytes(s, 0),
+                        pTerm, nTerm, isPrefix, piStartChild, piEndChild);
 
   /* We expect only one row.  We must execute another sqlite3_step()
    * to complete the iteration; otherwise the table will remain
    * locked. */
   rc = sqlite3_step(s);
   if( rc==SQLITE_ROW ) return SQLITE_ERROR;
   if( rc!=SQLITE_DONE ) return rc;
 
   return SQLITE_OK;
 }
 
 /* Traverse the tree represented by pData[nData] looking for
 ** pTerm[nTerm], placing its doclist into *out.  This is internal to
 ** loadSegment() to make error-handling cleaner.
 */
 static int loadSegmentInt(fulltext_vtab *v, const char *pData, int nData,
                           sqlite_int64 iLeavesEnd,
                           const char *pTerm, int nTerm, int isPrefix,
                           DataBuffer *out){
   /* Special case where root is a leaf. */
   if( *pData=='\0' ){
     return loadSegmentLeaf(v, pData, nData, pTerm, nTerm, isPrefix, out);
   }else{
     int rc;
     sqlite_int64 iStartChild, iEndChild;
 
     /* Process pData as an interior node, then loop down the tree
     ** until we find the set of leaf nodes to scan for the term.
     */
-    rc = getChildrenContaining(pData, nData, pTerm, nTerm, isPrefix,
-                               &iStartChild, &iEndChild);
-    if( rc!=SQLITE_OK ) return rc;
+    getChildrenContaining(pData, nData, pTerm, nTerm, isPrefix,
+                          &iStartChild, &iEndChild);
     while( iStartChild>iLeavesEnd ){
       sqlite_int64 iNextStart, iNextEnd;
       rc = loadAndGetChildrenContaining(v, iStartChild, pTerm, nTerm, isPrefix,
                                         &iNextStart, &iNextEnd);
       if( rc!=SQLITE_OK ) return rc;
 
       /* If we've branched, follow the end branch, too. */
       if( iStartChild!=iEndChild ){
         sqlite_int64 iDummy;
         rc = loadAndGetChildrenContaining(v, iEndChild, pTerm, nTerm, isPrefix,
@@ skipping 31 matching lines @@
 ** within a segment, with pairwise merges across segments, or across
 ** all segments at once.
 */
 static int loadSegment(fulltext_vtab *v, const char *pData, int nData,
                        sqlite_int64 iLeavesEnd,
                        const char *pTerm, int nTerm, int isPrefix,
                        DataBuffer *out){
   DataBuffer result;
   int rc;
 
-  /* Corrupt if segment root can't be valid. */
-  if( pData==NULL || nData<1 ) return SQLITE_CORRUPT_BKPT;
+  assert( nData>1 );
 
   /* This code should never be called with buffered updates. */
   assert( v->nPendingData<0 );
 
   dataBufferInit(&result, 0);
   rc = loadSegmentInt(v, pData, nData, iLeavesEnd,
                       pTerm, nTerm, isPrefix, &result);
   if( rc==SQLITE_OK && result.nData>0 ){
     if( out->nData==0 ){
       DataBuffer tmp = *out;
       *out = result;
       result = tmp;
     }else{
       DataBuffer merged;
       DLReader readers[2];
 
-      rc = dlrInit(&readers[0], DL_DEFAULT, out->pData, out->nData);
-      if( rc==SQLITE_OK ){
-        rc = dlrInit(&readers[1], DL_DEFAULT, result.pData, result.nData);
-        if( rc==SQLITE_OK ){
-          dataBufferInit(&merged, out->nData+result.nData);
-          rc = docListMerge(&merged, readers, 2);
-          dataBufferDestroy(out);
-          *out = merged;
-          dlrDestroy(&readers[1]);
-        }
-        dlrDestroy(&readers[0]);
-      }
+      dlrInit(&readers[0], DL_DEFAULT, out->pData, out->nData);
+      dlrInit(&readers[1], DL_DEFAULT, result.pData, result.nData);
+      dataBufferInit(&merged, out->nData+result.nData);
+      docListMerge(&merged, readers, 2);
+      dataBufferDestroy(out);
+      *out = merged;
+      dlrDestroy(&readers[0]);
+      dlrDestroy(&readers[1]);
     }
   }
-
   dataBufferDestroy(&result);
   return rc;
 }
 
 /* Scan the database and merge together the posting lists for the term
 ** into *out.
 */
 static int termSelect(fulltext_vtab *v, int iColumn,
                       const char *pTerm, int nTerm, int isPrefix,
                       DocListType iType, DataBuffer *out){
   DataBuffer doclist;
   sqlite3_stmt *s;
   int rc = sql_get_statement(v, SEGDIR_SELECT_ALL_STMT, &s);
   if( rc!=SQLITE_OK ) return rc;
 
   /* This code should never be called with buffered updates. */
   assert( v->nPendingData<0 );
 
   dataBufferInit(&doclist, 0);
 
   /* Traverse the segments from oldest to newest so that newer doclist
   ** elements for given docids overwrite older elements.
   */
   while( (rc = sqlite3_step(s))==SQLITE_ROW ){
     const char *pData = sqlite3_column_blob(s, 2);
     const int nData = sqlite3_column_bytes(s, 2);
     const sqlite_int64 iLeavesEnd = sqlite3_column_int64(s, 1);
-
-    /* Corrupt if we get back different types than we stored. */
-    if( sqlite3_column_type(s, 1)!=SQLITE_INTEGER ||
-        sqlite3_column_type(s, 2)!=SQLITE_BLOB ){
-      rc = SQLITE_CORRUPT_BKPT;
-      goto err;
-    }
-
     rc = loadSegment(v, pData, nData, iLeavesEnd, pTerm, nTerm, isPrefix,
                      &doclist);
     if( rc!=SQLITE_OK ) goto err;
   }
   if( rc==SQLITE_DONE ){
-    rc = SQLITE_OK;
     if( doclist.nData!=0 ){
       /* TODO(shess) The old term_select_all() code applied the column
       ** restrict as we merged segments, leading to smaller buffers.
       ** This is probably worthwhile to bring back, once the new storage
       ** system is checked in.
       */
       if( iColumn==v->nColumn) iColumn = -1;
-      rc = docListTrim(DL_DEFAULT, doclist.pData, doclist.nData,
-                       iColumn, iType, out);
+      docListTrim(DL_DEFAULT, doclist.pData, doclist.nData,
+                  iColumn, iType, out);
     }
+    rc = SQLITE_OK;
   }
 
  err:
-  sqlite3_reset(s);         /* So we don't leave a lock. */
   dataBufferDestroy(&doclist);
   return rc;
 }
 
 /****************************************************************/
 /* Used to hold hashtable data for sorting. */
 typedef struct TermData {
   const char *pTerm;
   int nTerm;
   DLCollector *pCollector;
@@ skipping 321 matching lines @@
 /* optimize() helper function.  Put the readers in order and iterate
 ** through them, merging doclists for matching terms into pWriter.
 ** Returns SQLITE_OK on success, or the SQLite error code which
 ** prevented success.
 */
 static int optimizeInternal(fulltext_vtab *v,
                             OptLeavesReader *readers, int nReaders,
                             LeafWriter *pWriter){
   int i, rc = SQLITE_OK;
   DataBuffer doclist, merged, tmp;
-  const char *pData;
 
   /* Order the readers. */
   i = nReaders;
   while( i-- > 0 ){
     optLeavesReaderReorder(&readers[i], nReaders-i);
   }
 
   dataBufferInit(&doclist, LEAF_MAX);
   dataBufferInit(&merged, LEAF_MAX);
 
   /* Exhausted readers bubble to the end, so when the first reader is
   ** at eof, all are at eof.
   */
   while( !optLeavesReaderAtEnd(&readers[0]) ){
 
     /* Figure out how many readers share the next term. */
     for(i=1; i<nReaders && !optLeavesReaderAtEnd(&readers[i]); i++){
       if( 0!=optLeavesReaderTermCmp(&readers[0], &readers[i]) ) break;
     }
 
-    pData = optLeavesReaderData(&readers[0]);
-    if( pData==NULL ){
-      rc = SQLITE_CORRUPT_BKPT;
-      break;
-    }
-
     /* Special-case for no merge. */
     if( i==1 ){
       /* Trim deletions from the doclist. */
       dataBufferReset(&merged);
-      rc = docListTrim(DL_DEFAULT,
-                       pData,
-                       optLeavesReaderDataBytes(&readers[0]),
-                       -1, DL_DEFAULT, &merged);
-      if( rc!= SQLITE_OK ) break;
+      docListTrim(DL_DEFAULT,
+                  optLeavesReaderData(&readers[0]),
+                  optLeavesReaderDataBytes(&readers[0]),
+                  -1, DL_DEFAULT, &merged);
     }else{
       DLReader dlReaders[MERGE_COUNT];
       int iReader, nReaders;
 
       /* Prime the pipeline with the first reader's doclist.  After
       ** one pass index 0 will reference the accumulated doclist.
       */
-      rc = dlrInit(&dlReaders[0], DL_DEFAULT,
-                   pData,
-                   optLeavesReaderDataBytes(&readers[0]));
-      if( rc!=SQLITE_OK ) break;
+      dlrInit(&dlReaders[0], DL_DEFAULT,
+              optLeavesReaderData(&readers[0]),
+              optLeavesReaderDataBytes(&readers[0]));
       iReader = 1;
 
       assert( iReader<i );  /* Must execute the loop at least once. */
       while( iReader<i ){
         /* Merge 16 inputs per pass. */
         for( nReaders=1; iReader<i && nReaders<MERGE_COUNT;
              iReader++, nReaders++ ){
-          pData = optLeavesReaderData(&readers[iReader]);
-          if( pData == NULL ){
-            rc = SQLITE_CORRUPT_BKPT;
-            break;
-          }
-          rc = dlrInit(&dlReaders[nReaders], DL_DEFAULT,
-                       pData,
-                       optLeavesReaderDataBytes(&readers[iReader]));
-          if( rc != SQLITE_OK ) break;
+          dlrInit(&dlReaders[nReaders], DL_DEFAULT,
+                  optLeavesReaderData(&readers[iReader]),
+                  optLeavesReaderDataBytes(&readers[iReader]));
         }
 
         /* Merge doclists and swap result into accumulator. */
-        if( rc==SQLITE_OK ){
-          dataBufferReset(&merged);
-          rc = docListMerge(&merged, dlReaders, nReaders);
-          tmp = merged;
-          merged = doclist;
-          doclist = tmp;
-        }
+        dataBufferReset(&merged);
+        docListMerge(&merged, dlReaders, nReaders);
+        tmp = merged;
+        merged = doclist;
+        doclist = tmp;
 
         while( nReaders-- > 0 ){
           dlrDestroy(&dlReaders[nReaders]);
         }
 
-        if( rc!=SQLITE_OK ) goto err;
-
         /* Accumulated doclist to reader 0 for next pass. */
-        rc = dlrInit(&dlReaders[0], DL_DEFAULT, doclist.pData, doclist.nData);
-        if( rc!=SQLITE_OK ) goto err;
+        dlrInit(&dlReaders[0], DL_DEFAULT, doclist.pData, doclist.nData);
       }
 
       /* Destroy reader that was left in the pipeline. */
       dlrDestroy(&dlReaders[0]);
 
       /* Trim deletions from the doclist. */
       dataBufferReset(&merged);
-      rc = docListTrim(DL_DEFAULT, doclist.pData, doclist.nData,
-                       -1, DL_DEFAULT, &merged);
-      if( rc!=SQLITE_OK ) goto err;
+      docListTrim(DL_DEFAULT, doclist.pData, doclist.nData,
+                  -1, DL_DEFAULT, &merged);
     }
 
     /* Only pass doclists with hits (skip if all hits deleted). */
     if( merged.nData>0 ){
       rc = leafWriterStep(v, pWriter,
                           optLeavesReaderTerm(&readers[0]),
                           optLeavesReaderTermBytes(&readers[0]),
                           merged.pData, merged.nData);
       if( rc!=SQLITE_OK ) goto err;
     }
@@ skipping 59 matching lines @@
     */
     leafWriterInit(iMaxLevel, 0, &writer);
 
     i = 0;
     while( (rc = sqlite3_step(s))==SQLITE_ROW ){
       sqlite_int64 iStart = sqlite3_column_int64(s, 0);
       sqlite_int64 iEnd = sqlite3_column_int64(s, 1);
       const char *pRootData = sqlite3_column_blob(s, 2);
       int nRootData = sqlite3_column_bytes(s, 2);
 
-      /* Corrupt if we get back different types than we stored. */
-      if( sqlite3_column_type(s, 0)!=SQLITE_INTEGER ||
-          sqlite3_column_type(s, 1)!=SQLITE_INTEGER ||
-          sqlite3_column_type(s, 2)!=SQLITE_BLOB ){
-        rc = SQLITE_CORRUPT_BKPT;
-        break;
-      }
-
       assert( i<nReaders );
       rc = leavesReaderInit(v, -1, iStart, iEnd, pRootData, nRootData,
                             &readers[i].reader);
       if( rc!=SQLITE_OK ) break;
 
       readers[i].segment = i;
       i++;
     }
 
     /* If we managed to successfully read them all, optimize them. */
     if( rc==SQLITE_DONE ){
       assert( i==nReaders );
       rc = optimizeInternal(v, readers, nReaders, &writer);
-    }else{
-      sqlite3_reset(s);      /* So we don't leave a lock. */
     }
 
     while( i-- > 0 ){
       leavesReaderDestroy(&readers[i].reader);
     }
     sqlite3_free(readers);
 
     /* If we've successfully gotten to here, delete the old segments
     ** and flush the interior structure of the new segment.
     */
@@ skipping 43 matching lines @@
 ** iStartBlockid and iEndBlockid, inclusive, or by the contents of
 ** pRootData if iStartBlockid is 0 (in which case the entire segment
 ** fit in a leaf).
 */
 static int collectSegmentTerms(fulltext_vtab *v, sqlite3_stmt *s,
                                fts2Hash *pTerms){
   const sqlite_int64 iStartBlockid = sqlite3_column_int64(s, 0);
   const sqlite_int64 iEndBlockid = sqlite3_column_int64(s, 1);
   const char *pRootData = sqlite3_column_blob(s, 2);
   const int nRootData = sqlite3_column_bytes(s, 2);
-  int rc;
   LeavesReader reader;
-
-  /* Corrupt if we get back different types than we stored. */
-  if( sqlite3_column_type(s, 0)!=SQLITE_INTEGER ||
-      sqlite3_column_type(s, 1)!=SQLITE_INTEGER ||
-      sqlite3_column_type(s, 2)!=SQLITE_BLOB ){
-    return SQLITE_CORRUPT_BKPT;
-  }
-
-  rc = leavesReaderInit(v, 0, iStartBlockid, iEndBlockid,
-                        pRootData, nRootData, &reader);
+  int rc = leavesReaderInit(v, 0, iStartBlockid, iEndBlockid,
+                            pRootData, nRootData, &reader);
   if( rc!=SQLITE_OK ) return rc;
 
   while( rc==SQLITE_OK && !leavesReaderAtEnd(&reader) ){
     const char *pTerm = leavesReaderTerm(&reader);
     const int nTerm = leavesReaderTermBytes(&reader);
     void *oldValue = sqlite3Fts2HashFind(pTerms, pTerm, nTerm);
     void *newValue = (void *)((char *)oldValue+1);
 
     /* From the comment before sqlite3Fts2HashInsert in fts2_hash.c,
     ** the data value passed is returned in case of malloc failure.
@@ skipping 141 matching lines @@
   }
 }
 
 /* Expand the DL_DEFAULT doclist in pData into a text result in
 ** pContext.
 */
 static void createDoclistResult(sqlite3_context *pContext,
                                 const char *pData, int nData){
   DataBuffer dump;
   DLReader dlReader;
-  int rc;
 
   assert( pData!=NULL && nData>0 );
 
-  rc = dlrInit(&dlReader, DL_DEFAULT, pData, nData);
-  if( rc!=SQLITE_OK ) return;
   dataBufferInit(&dump, 0);
-  for( ; rc==SQLITE_OK && !dlrAtEnd(&dlReader); rc = dlrStep(&dlReader) ){
+  dlrInit(&dlReader, DL_DEFAULT, pData, nData);
+  for( ; !dlrAtEnd(&dlReader); dlrStep(&dlReader) ){
     char buf[256];
     PLReader plReader;
 
-    rc = plrInit(&plReader, &dlReader);
-    if( rc!=SQLITE_OK ) break;
+    plrInit(&plReader, &dlReader);
     if( DL_DEFAULT==DL_DOCIDS || plrAtEnd(&plReader) ){
       sqlite3_snprintf(sizeof(buf), buf, "[%lld] ", dlrDocid(&dlReader));
       dataBufferAppend(&dump, buf, strlen(buf));
     }else{
       int iColumn = plrColumn(&plReader);
 
       sqlite3_snprintf(sizeof(buf), buf, "[%lld %d[",
                        dlrDocid(&dlReader), iColumn);
       dataBufferAppend(&dump, buf, strlen(buf));
 
-      for( ; !plrAtEnd(&plReader); rc = plrStep(&plReader) ){
-        if( rc!=SQLITE_OK ) break;
+      for( ; !plrAtEnd(&plReader); plrStep(&plReader) ){
         if( plrColumn(&plReader)!=iColumn ){
           iColumn = plrColumn(&plReader);
           sqlite3_snprintf(sizeof(buf), buf, "] %d[", iColumn);
           assert( dump.nData>0 );
           dump.nData--;                     /* Overwrite trailing space. */
           assert( dump.pData[dump.nData]==' ');
           dataBufferAppend(&dump, buf, strlen(buf));
         }
         if( DL_DEFAULT==DL_POSITIONS_OFFSETS ){
           sqlite3_snprintf(sizeof(buf), buf, "%d,%d,%d ",
                            plrPosition(&plReader),
                            plrStartOffset(&plReader), plrEndOffset(&plReader));
         }else if( DL_DEFAULT==DL_POSITIONS ){
           sqlite3_snprintf(sizeof(buf), buf, "%d ", plrPosition(&plReader));
         }else{
           assert( NULL=="Unhandled DL_DEFAULT value");
         }
         dataBufferAppend(&dump, buf, strlen(buf));
       }
       plrDestroy(&plReader);
-      if( rc!= SQLITE_OK ) break;
 
       assert( dump.nData>0 );
       dump.nData--;                     /* Overwrite trailing space. */
       assert( dump.pData[dump.nData]==' ');
       dataBufferAppend(&dump, "]] ", 3);
     }
   }
   dlrDestroy(&dlReader);
-  if( rc!=SQLITE_OK ){
-    dataBufferDestroy(&dump);
-    return;
-  }
 
   assert( dump.nData>0 );
   dump.nData--;                     /* Overwrite trailing space. */
   assert( dump.pData[dump.nData]==' ');
   dump.pData[dump.nData] = '\0';
   assert( dump.nData>0 );
 
   /* Passes ownership of dump's buffer to pContext. */
   sqlite3_result_text(pContext, dump.pData, dump.nData, sqlite3_free);
   dump.pData = NULL;
@@ skipping 273 matching lines @@
     ){
       rc = SQLITE_NOMEM;
     }
   }
 
   /* Create the virtual table wrapper around the hash-table and overload 
   ** the two scalar functions. If this is successful, register the
   ** module with sqlite.
   */
   if( SQLITE_OK==rc 
-#if GEARS_FTS2_CHANGES && !SQLITE_TEST
-      /* fts2_tokenizer() disabled for security reasons. */
-#else
    && SQLITE_OK==(rc = sqlite3Fts2InitHashTable(db, pHash, "fts2_tokenizer"))
-#endif
    && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1))
    && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", -1))
    && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", -1))
 #ifdef SQLITE_TEST
    && SQLITE_OK==(rc = sqlite3_overload_function(db, "dump_terms", -1))
    && SQLITE_OK==(rc = sqlite3_overload_function(db, "dump_doclist", -1))
 #endif
   ){
     return sqlite3_create_module_v2(
         db, "fts2", &fts2Module, (void *)pHash, hashDestroy
@@ skipping 17 matching lines @@
   sqlite3 *db, 
   char **pzErrMsg,
   const sqlite3_api_routines *pApi
 ){
   SQLITE_EXTENSION_INIT2(pApi)
   return sqlite3Fts2Init(db);
 }
 #endif
 
 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS2) */