fts3_tokenizer1.c.svn-base
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:6k
源码类别:

数据库系统

开发平台:

C/C++

  1. /*
  2. ** 2006 Oct 10
  3. **
  4. ** The author disclaims copyright to this source code.  In place of
  5. ** a legal notice, here is a blessing:
  6. **
  7. **    May you do good and not evil.
  8. **    May you find forgiveness for yourself and forgive others.
  9. **    May you share freely, never taking more than you give.
  10. **
  11. ******************************************************************************
  12. **
  13. ** Implementation of the "simple" full-text-search tokenizer.
  14. */
  15. /*
  16. ** The code in this file is only compiled if:
  17. **
  18. **     * The FTS3 module is being built as an extension
  19. **       (in which case SQLITE_CORE is not defined), or
  20. **
  21. **     * The FTS3 module is being built into the core of
  22. **       SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
  23. */
  24. #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
  25. #include <assert.h>
  26. #include <stdlib.h>
  27. #include <stdio.h>
  28. #include <string.h>
  29. #include <ctype.h>
  30. #include "fts3_tokenizer.h"
  31. typedef struct simple_tokenizer {
  32.   sqlite3_tokenizer base;
  33.   char delim[128];             /* flag ASCII delimiters */
  34. } simple_tokenizer;
  35. typedef struct simple_tokenizer_cursor {
  36.   sqlite3_tokenizer_cursor base;
  37.   const char *pInput;          /* input we are tokenizing */
  38.   int nBytes;                  /* size of the input */
  39.   int iOffset;                 /* current position in pInput */
  40.   int iToken;                  /* index of next token to be returned */
  41.   char *pToken;                /* storage for current token */
  42.   int nTokenAllocated;         /* space allocated to zToken buffer */
  43. } simple_tokenizer_cursor;
  44. /* Forward declaration */
  45. static const sqlite3_tokenizer_module simpleTokenizerModule;
  46. static int simpleDelim(simple_tokenizer *t, unsigned char c){
  47.   return c<0x80 && t->delim[c];
  48. }
  49. /*
  50. ** Create a new tokenizer instance.
  51. */
  52. static int simpleCreate(
  53.   int argc, const char * const *argv,
  54.   sqlite3_tokenizer **ppTokenizer
  55. ){
  56.   simple_tokenizer *t;
  57.   t = (simple_tokenizer *) sqlite3_malloc(sizeof(*t));
  58.   if( t==NULL ) return SQLITE_NOMEM;
  59.   memset(t, 0, sizeof(*t));
  60.   /* TODO(shess) Delimiters need to remain the same from run to run,
  61.   ** else we need to reindex.  One solution would be a meta-table to
  62.   ** track such information in the database, then we'd only want this
  63.   ** information on the initial create.
  64.   */
  65.   if( argc>1 ){
  66.     int i, n = strlen(argv[1]);
  67.     for(i=0; i<n; i++){
  68.       unsigned char ch = argv[1][i];
  69.       /* We explicitly don't support UTF-8 delimiters for now. */
  70.       if( ch>=0x80 ){
  71.         sqlite3_free(t);
  72.         return SQLITE_ERROR;
  73.       }
  74.       t->delim[ch] = 1;
  75.     }
  76.   } else {
  77.     /* Mark non-alphanumeric ASCII characters as delimiters */
  78.     int i;
  79.     for(i=1; i<0x80; i++){
  80.       t->delim[i] = !isalnum(i);
  81.     }
  82.   }
  83.   *ppTokenizer = &t->base;
  84.   return SQLITE_OK;
  85. }
  86. /*
  87. ** Destroy a tokenizer
  88. */
  89. static int simpleDestroy(sqlite3_tokenizer *pTokenizer){
  90.   sqlite3_free(pTokenizer);
  91.   return SQLITE_OK;
  92. }
  93. /*
  94. ** Prepare to begin tokenizing a particular string.  The input
  95. ** string to be tokenized is pInput[0..nBytes-1].  A cursor
  96. ** used to incrementally tokenize this string is returned in 
  97. ** *ppCursor.
  98. */
  99. static int simpleOpen(
  100.   sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
  101.   const char *pInput, int nBytes,        /* String to be tokenized */
  102.   sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
  103. ){
  104.   simple_tokenizer_cursor *c;
  105.   c = (simple_tokenizer_cursor *) sqlite3_malloc(sizeof(*c));
  106.   if( c==NULL ) return SQLITE_NOMEM;
  107.   c->pInput = pInput;
  108.   if( pInput==0 ){
  109.     c->nBytes = 0;
  110.   }else if( nBytes<0 ){
  111.     c->nBytes = (int)strlen(pInput);
  112.   }else{
  113.     c->nBytes = nBytes;
  114.   }
  115.   c->iOffset = 0;                 /* start tokenizing at the beginning */
  116.   c->iToken = 0;
  117.   c->pToken = NULL;               /* no space allocated, yet. */
  118.   c->nTokenAllocated = 0;
  119.   *ppCursor = &c->base;
  120.   return SQLITE_OK;
  121. }
  122. /*
  123. ** Close a tokenization cursor previously opened by a call to
  124. ** simpleOpen() above.
  125. */
  126. static int simpleClose(sqlite3_tokenizer_cursor *pCursor){
  127.   simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
  128.   sqlite3_free(c->pToken);
  129.   sqlite3_free(c);
  130.   return SQLITE_OK;
  131. }
  132. /*
  133. ** Extract the next token from a tokenization cursor.  The cursor must
  134. ** have been opened by a prior call to simpleOpen().
  135. */
  136. static int simpleNext(
  137.   sqlite3_tokenizer_cursor *pCursor,  /* Cursor returned by simpleOpen */
  138.   const char **ppToken,               /* OUT: *ppToken is the token text */
  139.   int *pnBytes,                       /* OUT: Number of bytes in token */
  140.   int *piStartOffset,                 /* OUT: Starting offset of token */
  141.   int *piEndOffset,                   /* OUT: Ending offset of token */
  142.   int *piPosition                     /* OUT: Position integer of token */
  143. ){
  144.   simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
  145.   simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer;
  146.   unsigned char *p = (unsigned char *)c->pInput;
  147.   while( c->iOffset<c->nBytes ){
  148.     int iStartOffset;
  149.     /* Scan past delimiter characters */
  150.     while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
  151.       c->iOffset++;
  152.     }
  153.     /* Count non-delimiter characters. */
  154.     iStartOffset = c->iOffset;
  155.     while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
  156.       c->iOffset++;
  157.     }
  158.     if( c->iOffset>iStartOffset ){
  159.       int i, n = c->iOffset-iStartOffset;
  160.       if( n>c->nTokenAllocated ){
  161.         c->nTokenAllocated = n+20;
  162.         c->pToken = sqlite3_realloc(c->pToken, c->nTokenAllocated);
  163.         if( c->pToken==NULL ) return SQLITE_NOMEM;
  164.       }
  165.       for(i=0; i<n; i++){
  166.         /* TODO(shess) This needs expansion to handle UTF-8
  167.         ** case-insensitivity.
  168.         */
  169.         unsigned char ch = p[iStartOffset+i];
  170.         c->pToken[i] = ch<0x80 ? tolower(ch) : ch;
  171.       }
  172.       *ppToken = c->pToken;
  173.       *pnBytes = n;
  174.       *piStartOffset = iStartOffset;
  175.       *piEndOffset = c->iOffset;
  176.       *piPosition = c->iToken++;
  177.       return SQLITE_OK;
  178.     }
  179.   }
  180.   return SQLITE_DONE;
  181. }
  182. /*
  183. ** The set of routines that implement the simple tokenizer
  184. */
  185. static const sqlite3_tokenizer_module simpleTokenizerModule = {
  186.   0,
  187.   simpleCreate,
  188.   simpleDestroy,
  189.   simpleOpen,
  190.   simpleClose,
  191.   simpleNext,
  192. };
  193. /*
  194. ** Allocate a new simple tokenizer.  Return a pointer to the new
  195. ** tokenizer in *ppModule
  196. */
  197. void sqlite3Fts3SimpleTokenizerModule(
  198.   sqlite3_tokenizer_module const**ppModule
  199. ){
  200.   *ppModule = &simpleTokenizerModule;
  201. }
  202. #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */