Import SQLite 3.10.2.

third_party/sqlite/src/ext/misc/spellfix.c

 /*
 ** 2012 April 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 338 matching lines @@
 **
 ** If pnMatch is not NULL, then *pnMatch is set to the number of bytes
 ** of zB that matched the pattern in zA. If zA does not end with a '*',
 ** then this value is always the number of bytes in zB (i.e. strlen(zB)).
 ** If zA does end in a '*', then it is the number of bytes in the prefix
 ** of zB that was deemed to match zA.
 */
 static int editdist1(const char *zA, const char *zB, int *pnMatch){
   int nA, nB;            /* Number of characters in zA[] and zB[] */
   int xA, xB;            /* Loop counters for zA[] and zB[] */
-  char cA, cB;           /* Current character of zA and zB */
+  char cA = 0, cB;       /* Current character of zA and zB */
   char cAprev, cBprev;   /* Previous character of zA and zB */
   char cAnext, cBnext;   /* Next character in zA and zB */
   int d;                 /* North-west cost value */
   int dc = 0;            /* North-west character value */
   int res;               /* Final result */
   int *m;                /* The cost matrix */
   char *cx;              /* Corresponding character values */
   int *toFree = 0;       /* Malloced space */
   int mStack[60+15];     /* Stack space to use if not too much is needed */
   int nMatch = 0;
@@ skipping 1340 matching lines @@
   sqlite3_value **argv
 ){
   const unsigned char *zIn = sqlite3_value_text(argv[0]);
   int nIn = sqlite3_value_bytes(argv[0]);
   int c, sz;
   int scriptMask = 0;
   int res;
 # define SCRIPT_LATIN       0x0001
 # define SCRIPT_CYRILLIC    0x0002
 # define SCRIPT_GREEK       0x0004
+# define SCRIPT_HEBREW      0x0008
+# define SCRIPT_ARABIC      0x0010
 
   while( nIn>0 ){
     c = utf8Read(zIn, nIn, &sz);
     zIn += sz;
     nIn -= sz;
-    if( c<0x02af ){
+    if( c<0x02af && (c>=0x80 || midClass[c&0x7f]<CCLASS_DIGIT) ){
       scriptMask |= SCRIPT_LATIN;
     }else if( c>=0x0400 && c<=0x04ff ){
       scriptMask |= SCRIPT_CYRILLIC;
     }else if( c>=0x0386 && c<=0x03ce ){
       scriptMask |= SCRIPT_GREEK;
+    }else if( c>=0x0590 && c<=0x05ff ){
+      scriptMask |= SCRIPT_HEBREW;
+    }else if( c>=0x0600 && c<=0x06ff ){
+      scriptMask |= SCRIPT_ARABIC;
     }
   }
   switch( scriptMask ){
     case 0:                res = 999; break;
     case SCRIPT_LATIN:     res = 215; break;
     case SCRIPT_CYRILLIC:  res = 220; break;
     case SCRIPT_GREEK:     res = 200; break;
+    case SCRIPT_HEBREW:    res = 125; break;
+    case SCRIPT_ARABIC:    res = 160; break;
     default:               res = 998; break;
   }
   sqlite3_result_int(context, res);
 }
 
 /* End transliterate
 ******************************************************************************
 ******************************************************************************
 ** Begin spellfix1 virtual table.
 */
@@ skipping 15 matching lines @@
   char *zTableName;          /* Name of the virtual table */
   char *zCostTable;          /* Table holding edit-distance cost numbers */
   EditDist3Config *pConfig3; /* Parsed edit distance costs */
 };
 
 /* Fuzzy-search cursor object */
 struct spellfix1_cursor {
   sqlite3_vtab_cursor base;    /* Base class - must be first */
   spellfix1_vtab *pVTab;       /* The table to which this cursor belongs */
   char *zPattern;              /* rhs of MATCH clause */
+  int idxNum;                  /* idxNum value passed to xFilter() */
   int nRow;                    /* Number of rows of content */
   int nAlloc;                  /* Number of allocated rows */
   int iRow;                    /* Current row of content */
   int iLang;                   /* Value of the langid= constraint */
   int iTop;                    /* Value of the top= constraint */
   int iScope;                  /* Value of the scope= constraint */
   int nSearch;                 /* Number of vocabulary items checked */
   sqlite3_stmt *pFullScan;     /* Shadow query for a full table scan */
   struct spellfix1_row {       /* For each row of content */
     sqlite3_int64 iRowid;         /* Rowid for this row */
@@ skipping 60 matching lines @@
 }
 
 /*
 ** Make a copy of a string.  Remove leading and trailing whitespace
 ** and dequote it.
 */
 static char *spellfix1Dequote(const char *zIn){
   char *zOut;
   int i, j;
   char c;
-  while( isspace(zIn[0]) ) zIn++;
+  while( isspace((unsigned char)zIn[0]) ) zIn++;
   zOut = sqlite3_mprintf("%s", zIn);
   if( zOut==0 ) return 0;
   i = (int)strlen(zOut);
 #if 0  /* The parser will never leave spaces at the end */
   while( i>0 && isspace(zOut[i-1]) ){ i--; }
 #endif
   zOut[i] = 0;
   c = zOut[0];
   if( c=='\'' || c=='"' ){
     for(i=1, j=0; ALWAYS(zOut[i]); i++){
@@ skipping 169 matching lines @@
 */
 static int spellfix1Close(sqlite3_vtab_cursor *cur){
   spellfix1_cursor *pCur = (spellfix1_cursor *)cur;
   spellfix1ResetCursor(pCur);
   spellfix1ResizeCursor(pCur, 0);
   sqlite3_free(pCur->zPattern);
   sqlite3_free(pCur);
   return SQLITE_OK;
 }
 
+#define SPELLFIX_IDXNUM_MATCH  0x01         /* word MATCH $str */
+#define SPELLFIX_IDXNUM_LANGID 0x02         /* langid == $langid */
+#define SPELLFIX_IDXNUM_TOP    0x04         /* top = $top */
+#define SPELLFIX_IDXNUM_SCOPE  0x08         /* scope = $scope */
+#define SPELLFIX_IDXNUM_DISTLT 0x10         /* distance < $distance */
+#define SPELLFIX_IDXNUM_DISTLE 0x20         /* distance <= $distance */
+#define SPELLFIX_IDXNUM_ROWID  0x40         /* rowid = $rowid */
+#define SPELLFIX_IDXNUM_DIST   (0x10|0x20)  /* DISTLT and DISTLE */
+
 /*
-** Search for terms of these forms:
 **
-**   (A)    word MATCH $str
-**   (B)    langid == $langid
-**   (C)    top = $top
-**   (D)    scope = $scope
-**   (E)    distance < $distance
-**   (F)    distance <= $distance
-**   (G)    rowid = $rowid
-**
-** The plan number is a bit mask formed with these bits:
-**
-**   0x01   (A) is found
-**   0x02   (B) is found
-**   0x04   (C) is found
-**   0x08   (D) is found
-**   0x10   (E) is found
-**   0x20   (F) is found
-**   0x40   (G) is found
+** The plan number is a bitmask of the SPELLFIX_IDXNUM_* values defined
+** above.
 **
 ** filter.argv[*] values contains $str, $langid, $top, $scope and $rowid
 ** if specified and in that order.
 */
 static int spellfix1BestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
   int iPlan = 0;
   int iLangTerm = -1;
   int iTopTerm = -1;
   int iScopeTerm = -1;
   int iDistTerm = -1;
   int iRowidTerm = -1;
   int i;
   const struct sqlite3_index_constraint *pConstraint;
   pConstraint = pIdxInfo->aConstraint;
   for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
     if( pConstraint->usable==0 ) continue;
 
     /* Terms of the form:  word MATCH $str */
-    if( (iPlan & 1)==0 
+    if( (iPlan & SPELLFIX_IDXNUM_MATCH)==0 
      && pConstraint->iColumn==SPELLFIX_COL_WORD
      && pConstraint->op==SQLITE_INDEX_CONSTRAINT_MATCH
     ){
-      iPlan |= 1;
+      iPlan |= SPELLFIX_IDXNUM_MATCH;
       pIdxInfo->aConstraintUsage[i].argvIndex = 1;
       pIdxInfo->aConstraintUsage[i].omit = 1;
     }
 
     /* Terms of the form:  langid = $langid  */
-    if( (iPlan & 2)==0
+    if( (iPlan & SPELLFIX_IDXNUM_LANGID)==0
      && pConstraint->iColumn==SPELLFIX_COL_LANGID
      && pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ
     ){
-      iPlan |= 2;
+      iPlan |= SPELLFIX_IDXNUM_LANGID;
       iLangTerm = i;
     }
 
     /* Terms of the form:  top = $top */
-    if( (iPlan & 4)==0
+    if( (iPlan & SPELLFIX_IDXNUM_TOP)==0
      && pConstraint->iColumn==SPELLFIX_COL_TOP
      && pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ
     ){
-      iPlan |= 4;
+      iPlan |= SPELLFIX_IDXNUM_TOP;
       iTopTerm = i;
     }
 
     /* Terms of the form:  scope = $scope */
-    if( (iPlan & 8)==0
+    if( (iPlan & SPELLFIX_IDXNUM_SCOPE)==0
      && pConstraint->iColumn==SPELLFIX_COL_SCOPE
      && pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ
     ){
-      iPlan |= 8;
+      iPlan |= SPELLFIX_IDXNUM_SCOPE;
       iScopeTerm = i;
     }
 
     /* Terms of the form:  distance < $dist or distance <= $dist */
-    if( (iPlan & (16|32))==0
+    if( (iPlan & SPELLFIX_IDXNUM_DIST)==0
      && pConstraint->iColumn==SPELLFIX_COL_DISTANCE
      && (pConstraint->op==SQLITE_INDEX_CONSTRAINT_LT
           || pConstraint->op==SQLITE_INDEX_CONSTRAINT_LE)
     ){
-      iPlan |= pConstraint->op==SQLITE_INDEX_CONSTRAINT_LT ? 16 : 32;
+      if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_LT ){
+        iPlan |= SPELLFIX_IDXNUM_DISTLT;
+      }else{
+        iPlan |= SPELLFIX_IDXNUM_DISTLE;
+      }
       iDistTerm = i;
     }
 
     /* Terms of the form:  distance < $dist or distance <= $dist */
-    if( (iPlan & 64)==0
+    if( (iPlan & SPELLFIX_IDXNUM_ROWID)==0
      && pConstraint->iColumn<0
      && pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ
     ){
-      iPlan |= 64;
+      iPlan |= SPELLFIX_IDXNUM_ROWID;
       iRowidTerm = i;
     }
   }
-  if( iPlan&1 ){
+  if( iPlan&SPELLFIX_IDXNUM_MATCH ){
     int idx = 2;
     pIdxInfo->idxNum = iPlan;
     if( pIdxInfo->nOrderBy==1
      && pIdxInfo->aOrderBy[0].iColumn==SPELLFIX_COL_SCORE
      && pIdxInfo->aOrderBy[0].desc==0
     ){
       pIdxInfo->orderByConsumed = 1;  /* Default order by iScore */
     }
-    if( iPlan&2 ){
+    if( iPlan&SPELLFIX_IDXNUM_LANGID ){
       pIdxInfo->aConstraintUsage[iLangTerm].argvIndex = idx++;
       pIdxInfo->aConstraintUsage[iLangTerm].omit = 1;
     }
-    if( iPlan&4 ){
+    if( iPlan&SPELLFIX_IDXNUM_TOP ){
       pIdxInfo->aConstraintUsage[iTopTerm].argvIndex = idx++;
       pIdxInfo->aConstraintUsage[iTopTerm].omit = 1;
     }
-    if( iPlan&8 ){
+    if( iPlan&SPELLFIX_IDXNUM_SCOPE ){
       pIdxInfo->aConstraintUsage[iScopeTerm].argvIndex = idx++;
       pIdxInfo->aConstraintUsage[iScopeTerm].omit = 1;
     }
-    if( iPlan&(16|32) ){
+    if( iPlan&SPELLFIX_IDXNUM_DIST ){
       pIdxInfo->aConstraintUsage[iDistTerm].argvIndex = idx++;
       pIdxInfo->aConstraintUsage[iDistTerm].omit = 1;
     }
     pIdxInfo->estimatedCost = 1e5;
-  }else if( (iPlan & 64) ){
-    pIdxInfo->idxNum = 64;
+  }else if( (iPlan & SPELLFIX_IDXNUM_ROWID) ){
+    pIdxInfo->idxNum = SPELLFIX_IDXNUM_ROWID;
     pIdxInfo->aConstraintUsage[iRowidTerm].argvIndex = 1;
     pIdxInfo->aConstraintUsage[iRowidTerm].omit = 1;
     pIdxInfo->estimatedCost = 5;
   }else{
     pIdxInfo->idxNum = 0;
     pIdxInfo->estimatedCost = 1e50;
   }
   return SQLITE_OK;
 }
 
@@ skipping 130 matching lines @@
     }else{
       zK1 = (const char*)sqlite3_column_text(pStmt, 3);
       if( zK1==0 ) continue;
       iDist = editdist1(p->zPattern, zK1, 0);
     }
     if( iDist<0 ){
       p->rc = SQLITE_NOMEM;
       break;
     }
     pCur->nSearch++;
-    iScore = spellfix1Score(iDist,iRank);
+    
+    /* If there is a "distance < $dist" or "distance <= $dist" constraint,
+    ** check if this row meets it. If not, jump back up to the top of the
+    ** loop to process the next row. Otherwise, if the row does match the
+    ** distance constraint, check if the pCur->a[] array is already full.
+    ** If it is and no explicit "top = ?" constraint was present in the
+    ** query, grow the array to ensure there is room for the new entry. */
+    assert( (p->iMaxDist>=0)==((pCur->idxNum & SPELLFIX_IDXNUM_DIST) ? 1 : 0) );
     if( p->iMaxDist>=0 ){
       if( iDist>p->iMaxDist ) continue;
-      if( pCur->nRow>=pCur->nAlloc-1 ){
+      if( pCur->nRow>=pCur->nAlloc && (pCur->idxNum & SPELLFIX_IDXNUM_TOP)==0 ){
         spellfix1ResizeCursor(pCur, pCur->nAlloc*2 + 10);
         if( pCur->a==0 ) break;
       }
-      idx = pCur->nRow;
-    }else if( pCur->nRow<pCur->nAlloc ){
+    }
+
+    iScore = spellfix1Score(iDist,iRank);
+    if( pCur->nRow<pCur->nAlloc ){
       idx = pCur->nRow;
     }else if( iScore<iWorst ){
       idx = idxWorst;
       sqlite3_free(pCur->a[idx].zWord);
     }else{
       continue;
     }
+
     pCur->a[idx].zWord = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
     if( pCur->a[idx].zWord==0 ){
       p->rc = SQLITE_NOMEM;
       break;
     }
     pCur->a[idx].iRowid = sqlite3_column_int64(pStmt, 0);
     pCur->a[idx].iRank = iRank;
     pCur->a[idx].iDistance = iDist;
     pCur->a[idx].iScore = iScore;
     pCur->a[idx].iMatchlen = iMatchlen;
@@ skipping 14 matching lines @@
   rc = sqlite3_reset(pStmt);
   if( rc ) p->rc = rc;
 }
 
 /*
 ** This version of the xFilter method work if the MATCH term is present
 ** and we are doing a scan.
 */
 static int spellfix1FilterForMatch(
   spellfix1_cursor *pCur,
-  int idxNum,
   int argc,
   sqlite3_value **argv
 ){
+  int idxNum = pCur->idxNum;
   const unsigned char *zMatchThis;   /* RHS of the MATCH operator */
   EditDist3FromString *pMatchStr3 = 0; /* zMatchThis as an editdist string */
   char *zPattern;                    /* Transliteration of zMatchThis */
   int nPattern;                      /* Length of zPattern */
   int iLimit = 20;                   /* Max number of rows of output */
   int iScope = 3;                    /* Use this many characters of zClass */
   int iLang = 0;                     /* Language code */
   char *zSql;                        /* SQL of shadow table query */
   sqlite3_stmt *pStmt = 0;           /* Shadow table query */
   int rc;                            /* Result code */
@@ skipping 91 matching lines @@
   sqlite3_finalize(pStmt);
   editDist3FromStringDelete(pMatchStr3);
   return x.rc;
 }
 
 /*
 ** This version of xFilter handles a full-table scan case
 */
 static int spellfix1FilterForFullScan(
   spellfix1_cursor *pCur,
-  int idxNum,
   int argc,
   sqlite3_value **argv
 ){
   int rc = SQLITE_OK;
+  int idxNum = pCur->idxNum;
   char *zSql;
   spellfix1_vtab *pVTab = pCur->pVTab;
   spellfix1ResetCursor(pCur);
   assert( idxNum==0 || idxNum==64 );
   zSql = sqlite3_mprintf(
      "SELECT word, rank, NULL, langid, id FROM \"%w\".\"%w_vocab\"%s",
      pVTab->zDbName, pVTab->zTableName,
      ((idxNum & 64) ? " WHERE rowid=?" : "")
   );
   if( zSql==0 ) return SQLITE_NOMEM;
@@ skipping 20 matching lines @@
 ** it starts its output over again.  Always called at least once
 ** prior to any spellfix1Column, spellfix1Rowid, or spellfix1Eof call.
 */
 static int spellfix1Filter(
   sqlite3_vtab_cursor *cur, 
   int idxNum, const char *idxStr,
   int argc, sqlite3_value **argv
 ){
   spellfix1_cursor *pCur = (spellfix1_cursor *)cur;
   int rc;
+  pCur->idxNum = idxNum;
   if( idxNum & 1 ){
-    rc = spellfix1FilterForMatch(pCur, idxNum, argc, argv);
+    rc = spellfix1FilterForMatch(pCur, argc, argv);
   }else{
-    rc = spellfix1FilterForFullScan(pCur, idxNum, argc, argv);
+    rc = spellfix1FilterForFullScan(pCur, argc, argv);
   }
   return rc;
 }
 
 
 /*
 ** Advance a cursor to its next row of output
 */
 static int spellfix1Next(sqlite3_vtab_cursor *cur){
   spellfix1_cursor *pCur = (spellfix1_cursor *)cur;
@@ skipping 111 matching lines @@
   spellfix1_cursor *pCur = (spellfix1_cursor*)cur;
   if( pCur->pFullScan ){
     *pRowid = sqlite3_column_int64(pCur->pFullScan, 4);
   }else{
     *pRowid = pCur->a[pCur->iRow].iRowid;
   }
   return SQLITE_OK;
 }
 
 /*
+** This function is called by the xUpdate() method. It returns a string
+** containing the conflict mode that xUpdate() should use for the current
+** operation. One of: "ROLLBACK", "IGNORE", "ABORT" or "REPLACE".
+*/
+static const char *spellfix1GetConflict(sqlite3 *db){
+  static const char *azConflict[] = {
+    /* Note: Instead of "FAIL" - "ABORT". */
+    "ROLLBACK", "IGNORE", "ABORT", "ABORT", "REPLACE"
+  };
+  int eConflict = sqlite3_vtab_on_conflict(db);
+
+  assert( eConflict==SQLITE_ROLLBACK || eConflict==SQLITE_IGNORE
+       || eConflict==SQLITE_FAIL || eConflict==SQLITE_ABORT
+       || eConflict==SQLITE_REPLACE
+  );
+  assert( SQLITE_ROLLBACK==1 );
+  assert( SQLITE_IGNORE==2 );
+  assert( SQLITE_FAIL==3 );
+  assert( SQLITE_ABORT==4 );
+  assert( SQLITE_REPLACE==5 );
+
+  return azConflict[eConflict-1];
+}
+
+/*
 ** The xUpdate() method.
 */
 static int spellfix1Update(
   sqlite3_vtab *pVTab,
   int argc,
   sqlite3_value **argv,
   sqlite_int64 *pRowid
 ){
   int rc = SQLITE_OK;
   sqlite3_int64 rowid, newRowid;
@@ skipping 10 matching lines @@
     const unsigned char *zWord = sqlite3_value_text(argv[SPELLFIX_COL_WORD+2]);
     int nWord = sqlite3_value_bytes(argv[SPELLFIX_COL_WORD+2]);
     int iLang = sqlite3_value_int(argv[SPELLFIX_COL_LANGID+2]);
     int iRank = sqlite3_value_int(argv[SPELLFIX_COL_RANK+2]);
     const unsigned char *zSoundslike =
            sqlite3_value_text(argv[SPELLFIX_COL_SOUNDSLIKE+2]);
     int nSoundslike = sqlite3_value_bytes(argv[SPELLFIX_COL_SOUNDSLIKE+2]);
     char *zK1, *zK2;
     int i;
     char c;
+    const char *zConflict = spellfix1GetConflict(db);
 
     if( zWord==0 ){
       /* Inserts of the form:  INSERT INTO table(command) VALUES('xyzzy');
       ** cause zWord to be NULL, so we look at the "command" column to see
       ** what special actions to take */
       const char *zCmd = 
          (const char*)sqlite3_value_text(argv[SPELLFIX_COL_COMMAND+2]);
       if( zCmd==0 ){
         pVTab->zErrMsg = sqlite3_mprintf("NOT NULL constraint failed: %s.word",
                                          p->zTableName);
@@ skipping 40 matching lines @@
       if( sqlite3_value_type(argv[1])==SQLITE_NULL ){
         spellfix1DbExec(&rc, db,
                "INSERT INTO \"%w\".\"%w_vocab\"(rank,langid,word,k1,k2) "
                "VALUES(%d,%d,%Q,%Q,%Q)",
                p->zDbName, p->zTableName,
                iRank, iLang, zWord, zK1, zK2
         );
       }else{
         newRowid = sqlite3_value_int64(argv[1]);
         spellfix1DbExec(&rc, db,
-               "INSERT INTO \"%w\".\"%w_vocab\"(id,rank,langid,word,k1,k2) "
-               "VALUES(%lld,%d,%d,%Q,%Q,%Q)",
-               p->zDbName, p->zTableName,
-               newRowid, iRank, iLang, zWord, zK1, zK2
+            "INSERT OR %s INTO \"%w\".\"%w_vocab\"(id,rank,langid,word,k1,k2) "
+            "VALUES(%lld,%d,%d,%Q,%Q,%Q)",
+            zConflict, p->zDbName, p->zTableName,
+            newRowid, iRank, iLang, zWord, zK1, zK2
         );
       }
       *pRowid = sqlite3_last_insert_rowid(db);
     }else{
       rowid = sqlite3_value_int64(argv[0]);
       newRowid = *pRowid = sqlite3_value_int64(argv[1]);
       spellfix1DbExec(&rc, db,
-             "UPDATE \"%w\".\"%w_vocab\" SET id=%lld, rank=%d, langid=%d,"
+             "UPDATE OR %s \"%w\".\"%w_vocab\" SET id=%lld, rank=%d, langid=%d,"
              " word=%Q, k1=%Q, k2=%Q WHERE id=%lld",
-             p->zDbName, p->zTableName, newRowid, iRank, iLang,
+             zConflict, p->zDbName, p->zTableName, newRowid, iRank, iLang,
              zWord, zK1, zK2, rowid
       );
     }
     sqlite3_free(zK1);
     sqlite3_free(zK2);
   }
   return rc;
 }
 
 /*
@@ skipping 94 matching lines @@
   sqlite3 *db, 
   char **pzErrMsg, 
   const sqlite3_api_routines *pApi
 ){
   SQLITE_EXTENSION_INIT2(pApi);
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   return spellfix1Register(db);
 #endif
   return SQLITE_OK;
 }