[sql] Import reference version of SQLite 3.10.2.

third_party/sqlite/sqlite-src-3100200/src/test8.c

 /*
 ** 2006 June 10
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
@@ skipping 188 matching lines @@
       rc = SQLITE_NOMEM;
       goto out;
     }
 
     /* Copy the column names into the allocated space and set up the
     ** pointers in the aCol[] array.
     */
     zSpace = (char *)(&aCol[nCol]);
     for(ii=0; ii<nCol; ii++){
       aCol[ii] = zSpace;
-      zSpace += sprintf(zSpace, "%s", sqlite3_column_name(pStmt, ii));
-      zSpace++;
+      sqlite3_snprintf(nBytes, zSpace, "%s", sqlite3_column_name(pStmt,ii));
+      zSpace += (int)strlen(zSpace) + 1;
     }
     assert( (zSpace-nBytes)==(char *)aCol );
   }
 
   *paCol = aCol;
   *pnCol = nCol;
 
 out:
   sqlite3_finalize(pStmt);
   return rc;
@@ skipping 420 matching lines @@
 /*
 ** Compute a simple hash of the null terminated string zString.
 **
 ** This module uses only sqlite3_index_info.idxStr, not 
 ** sqlite3_index_info.idxNum. So to test idxNum, when idxStr is set
 ** in echoBestIndex(), idxNum is set to the corresponding hash value.
 ** In echoFilter(), code assert()s that the supplied idxNum value is
 ** indeed the hash of the supplied idxStr.
 */
 static int hashString(const char *zString){
-  int val = 0;
+  u32 val = 0;
   int ii;
   for(ii=0; zString[ii]; ii++){
     val = (val << 3) + (int)zString[ii];
   }
-  return val;
+  return (int)(val&0x7fffffff);
 }
 
 /* 
 ** Echo virtual table module xFilter method.
 */
 static int echoFilter(
   sqlite3_vtab_cursor *pVtabCursor, 
   int idxNum, const char *idxStr,
   int argc, sqlite3_value **argv
 ){
@@ skipping 72 matching lines @@
       *pRc = SQLITE_NOMEM;
     }
   }
   *pzStr = zIn;
   if( doFree ){
     sqlite3_free(zAppend);
   }
 }
 
 /*
+** This function returns a pointer to an sqlite3_malloc()ed buffer 
+** containing the select-list (the thing between keywords SELECT and FROM)
+** to query the underlying real table with for the scan described by
+** argument pIdxInfo.
+**
+** If the current SQLite version is earlier than 3.10.0, this is just "*"
+** (select all columns). Or, for version 3.10.0 and greater, the list of
+** columns identified by the pIdxInfo->colUsed mask.
+*/
+static char *echoSelectList(echo_vtab *pTab, sqlite3_index_info *pIdxInfo){
+  char *zRet = 0;
+  if( sqlite3_libversion_number()<3010000 ){
+    zRet = sqlite3_mprintf(", *");
+  }else{
+    int i;
+    for(i=0; i<pTab->nCol; i++){
+      if( pIdxInfo->colUsed & ((sqlite3_uint64)1 << (i>=63 ? 63 : i)) ){
+        zRet = sqlite3_mprintf("%z, %s", zRet, pTab->aCol[i]);
+      }else{
+        zRet = sqlite3_mprintf("%z, NULL", zRet);
+      }
+      if( !zRet ) break;
+    }
+  }
+  return zRet;
+}
+
+/*
 ** The echo module implements the subset of query constraints and sort
 ** orders that may take advantage of SQLite indices on the underlying
 ** real table. For example, if the real table is declared as:
 **
 **     CREATE TABLE real(a, b, c);
 **     CREATE INDEX real_index ON real(b);
 **
 ** then the echo module handles WHERE or ORDER BY clauses that refer
 ** to the column "b", but not "a" or "c". If a multi-column index is
 ** present, only its left most column is considered. 
 **
 ** This xBestIndex method encodes the proposed search strategy as
 ** an SQL query on the real table underlying the virtual echo module 
 ** table and stores the query in sqlite3_index_info.idxStr. The SQL
 ** statement is of the form:
 **
 **   SELECT rowid, * FROM <real-table> ?<where-clause>? ?<order-by-clause>?
 **
 ** where the <where-clause> and <order-by-clause> are determined
 ** by the contents of the structure pointed to by the pIdxInfo argument.
 */
 static int echoBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
   int ii;
   char *zQuery = 0;
+  char *zCol = 0;
   char *zNew;
   int nArg = 0;
   const char *zSep = "WHERE";
   echo_vtab *pVtab = (echo_vtab *)tab;
   sqlite3_stmt *pStmt = 0;
   Tcl_Interp *interp = pVtab->interp;
 
-  int nRow;
+  int nRow = 0;
   int useIdx = 0;
   int rc = SQLITE_OK;
   int useCost = 0;
-  double cost;
+  double cost = 0;
   int isIgnoreUsable = 0;
   if( Tcl_GetVar(interp, "echo_module_ignore_usable", TCL_GLOBAL_ONLY) ){
     isIgnoreUsable = 1;
   }
 
   if( simulateVtabError(pVtab, "xBestIndex") ){
     return SQLITE_ERROR;
   }
 
   /* Determine the number of rows in the table and store this value in local
@@ skipping 15 matching lines @@
       return rc;
     }
     sqlite3_step(pStmt);
     nRow = sqlite3_column_int(pStmt, 0);
     rc = sqlite3_finalize(pStmt);
     if( rc!=SQLITE_OK ){
       return rc;
     }
   }
 
-  zQuery = sqlite3_mprintf("SELECT rowid, * FROM %Q", pVtab->zTableName);
-  if( !zQuery ){
-    return SQLITE_NOMEM;
-  }
+  zCol = echoSelectList(pVtab, pIdxInfo);
+  if( !zCol ) return SQLITE_NOMEM;
+  zQuery = sqlite3_mprintf("SELECT rowid%z FROM %Q", zCol, pVtab->zTableName);
+  if( !zQuery ) return SQLITE_NOMEM;
+
   for(ii=0; ii<pIdxInfo->nConstraint; ii++){
     const struct sqlite3_index_constraint *pConstraint;
     struct sqlite3_index_constraint_usage *pUsage;
     int iCol;
 
     pConstraint = &pIdxInfo->aConstraint[ii];
     pUsage = &pIdxInfo->aConstraintUsage[ii];
 
     if( !isIgnoreUsable && !pConstraint->usable ) continue;
 
     iCol = pConstraint->iColumn;
     if( iCol<0 || pVtab->aIndex[iCol] ){
-      char *zCol = iCol>=0 ? pVtab->aCol[iCol] : "rowid";
+      char *zNewCol = iCol>=0 ? pVtab->aCol[iCol] : "rowid";
       char *zOp = 0;
       useIdx = 1;
       switch( pConstraint->op ){
         case SQLITE_INDEX_CONSTRAINT_EQ:
           zOp = "="; break;
         case SQLITE_INDEX_CONSTRAINT_LT:
           zOp = "<"; break;
         case SQLITE_INDEX_CONSTRAINT_GT:
           zOp = ">"; break;
         case SQLITE_INDEX_CONSTRAINT_LE:
           zOp = "<="; break;
         case SQLITE_INDEX_CONSTRAINT_GE:
           zOp = ">="; break;
         case SQLITE_INDEX_CONSTRAINT_MATCH:
+          /* Purposely translate the MATCH operator into a LIKE, which
+          ** will be used by the next block of code to construct a new
+          ** query.  It should also be noted here that the next block
+          ** of code requires the first letter of this operator to be
+          ** in upper-case to trigger the special MATCH handling (i.e.
+          ** wrapping the bound parameter with literal '%'s).
+          */
           zOp = "LIKE"; break;
+        case SQLITE_INDEX_CONSTRAINT_LIKE:
+          zOp = "like"; break;
+        case SQLITE_INDEX_CONSTRAINT_GLOB:
+          zOp = "glob"; break;
+        case SQLITE_INDEX_CONSTRAINT_REGEXP:
+          zOp = "regexp"; break;
       }
       if( zOp[0]=='L' ){
         zNew = sqlite3_mprintf(" %s %s LIKE (SELECT '%%'||?||'%%')", 
-                               zSep, zCol);
+                               zSep, zNewCol);
       } else {
-        zNew = sqlite3_mprintf(" %s %s %s ?", zSep, zCol, zOp);
+        zNew = sqlite3_mprintf(" %s %s %s ?", zSep, zNewCol, zOp);
       }
       string_concat(&zQuery, zNew, 1, &rc);
 
       zSep = "AND";
       pUsage->argvIndex = ++nArg;
       pUsage->omit = 1;
     }
   }
 
   /* If there is only one term in the ORDER BY clause, and it is
   ** on a column that this virtual table has an index for, then consume 
   ** the ORDER BY clause.
   */
   if( pIdxInfo->nOrderBy==1 && (
         pIdxInfo->aOrderBy->iColumn<0 ||
         pVtab->aIndex[pIdxInfo->aOrderBy->iColumn]) ){
     int iCol = pIdxInfo->aOrderBy->iColumn;
-    char *zCol = iCol>=0 ? pVtab->aCol[iCol] : "rowid";
+    char *zNewCol = iCol>=0 ? pVtab->aCol[iCol] : "rowid";
     char *zDir = pIdxInfo->aOrderBy->desc?"DESC":"ASC";
-    zNew = sqlite3_mprintf(" ORDER BY %s %s", zCol, zDir);
+    zNew = sqlite3_mprintf(" ORDER BY %s %s", zNewCol, zDir);
     string_concat(&zQuery, zNew, 1, &rc);
     pIdxInfo->orderByConsumed = 1;
   }
 
   appendToEchoModule(pVtab->interp, "xBestIndex");;
   appendToEchoModule(pVtab->interp, zQuery);
 
   if( !zQuery ){
     return rc;
   }
@@ skipping 32 matching lines @@
 int echoUpdate(
   sqlite3_vtab *tab, 
   int nData, 
   sqlite3_value **apData, 
   sqlite_int64 *pRowid
 ){
   echo_vtab *pVtab = (echo_vtab *)tab;
   sqlite3 *db = pVtab->db;
   int rc = SQLITE_OK;
 
-  sqlite3_stmt *pStmt;
+  sqlite3_stmt *pStmt = 0;
   char *z = 0;               /* SQL statement to execute */
   int bindArgZero = 0;       /* True to bind apData[0] to sql var no. nData */
   int bindArgOne = 0;        /* True to bind apData[1] to sql var no. 1 */
   int i;                     /* Counter variable used by for loops */
 
   assert( nData==pVtab->nCol+2 || nData==1 );
 
   /* Ticket #3083 - make sure we always start a transaction prior to
   ** making any changes to a virtual table */
   assert( pVtab->inTransaction );
@@ skipping 446 matching lines @@
      { "sqlite3_declare_vtab",       declare_vtab, 0 },
   };
   int i;
   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
     Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 
         aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
   }
 #endif
   return TCL_OK;
 }