【转】sqlite fts3自定义分词器

     sqlite3通过使用fts3虚表支持全文搜索，默认支持simple和porter两种分词器，并提供了接口来自定义分词器。这里我们利用mmseg来构造自定义的中文分词器。
      虽然sqlite在fts3_tokenizer.h中提供了各种接口供用户自定义分词器，但其并未提供c函数供用户来注册自定义的分词器，分词器的注册必须使用sql语句来完成。
    SELECT fts3_tokenizer(<tokenizer-name>, <sqlite3_tokenizer_module ptr>);
    其中tokenizer-name是分词器的名称，sqlite3_tokenizer_module ptr只一个指向sqlite3_tokenizer_module结构的指针并且编码为SQL blob。下面是官方给出的注册函数：
int registerTokenizer(
        sqlite3 *db,
        char *zName,
        const sqlite3_tokenizer_module *p
        ){
    int rc;
    sqlite3_stmt *pStmt;
    const char *zSql = "SELECT fts3_tokenizer(?, ?)";
    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
    if( rc!=SQLITE_OK ){
        return rc;
    }
    sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
    sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
    sqlite3_step(pStmt);
    return sqlite3_finalize(pStmt);
}

    要想实现自定义的分词器，最关键的时是得到指向sqlite3_tokenizer_module结构的一个指针，sqlite3_tokenizer_module结构体定义如下：
struct sqlite3_tokenizer_module {
int iVersion; //版本号，必须设置为0
int (*xCreate)( //创建虚表时自动调用并创建分词器
    int argc,                          
    const char *const*argv,           
    sqlite3_tokenizer **ppTokenizer   
);
int (*xDestroy)(sqlite3_tokenizer *pTokenizer); //数据库连接关闭时自动调用，用于销毁资源
int (*xOpen)( //插入数据或检索时自动调用以进行分词
    sqlite3_tok enizer *pTokenizer,     
    const char *pInput, int nBytes,    
    sqlite3_tokenizer_cursor **ppCursor
);

int (*xClose)(sqlite3_tokenizer_cursor *pCursor); //分词结果提取完毕后自动调用

int (*xNext)( //逐个提取分词结果
    sqlite3_tokenizer_cursor *pCursor,  
    const char **ppToken, int *pnBytes,
    int *piStartOffset,
    int *piEndOffset,
    int *piPosition
);
};
    有几点需要注意的是：
    1 分词引擎使用sql语句注册意味着每建立一个sqlite连接都必须注册一次分词器，对于需要使用词库的中文分词器来说也意味着巨大的内存消耗。
    2 在检索时分词结果的提取和语义的解析式交替进行的。例如我们搜索"kanif OR sqlite"的时候，引擎先将全部传入到分词器，在调用一次next获取到词 kanif后，在将词sqlite传入到分词器，直到全部解析完毕。
    3 由于中文分词本身的特殊性，例如"北京市"很有可能视为一个完整的词，这样在搜索"北京"的时候就无法获取到结果。如果分词器支持将"北京市"切分为"北 京市"和"北京"或者将十一月切分为"11月"和"十一"，那么需注意(*xNext)函数中的piStartOffset和piEndOffset参 数。经测试在插入数据的时候这两个参数无实际用途，但在查询的时候这两个参数决定了下一次的输入串。

附：
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <sys/types.h>

#include "fts3_tokenizer.h"
#include "mmseg/mmseg.cpp"

static bool loadDic = true;

typedef struct cus_tokenizer {
sqlite3_tokenizer base;
} cus_tokenizer;

typedef struct cus_tokenizer_cursor {
sqlite3_tokenizer_cursor base;
char *pInput;
int nBytes;
int iToken;
char *pToken;
rmmseg::Algorithm *pAlgor;
} cus_tokenizer_cursor;

void initmmseg(void){
    if(!loadDic)
        return;
    mmseg_load_words("chars.dic");
    mmseg_load_words("words.dic");
    loadDic = False;
}

static int cusCreate(
int argc, const char * const *argv,
sqlite3_tokenizer **ppTokenizer
){
cus_tokenizer *t;
t = (cus_tokenizer *) sqlite3_malloc(sizeof(*t));
if( t==NULL ) return SQLITE_NOMEM;
memset(t, 0, sizeof(*t));
initmmseg();
*ppTokenizer = &t->base;
return SQLITE_OK;
}

static int cusDestroy(sqlite3_tokenizer *pTokenizer){
sqlite3_free(pTokenizer);
return SQLITE_OK;
}

static int cusOpen(
sqlite3_tokenizer *pTokenizer,         /* The tokenizer */
const char *pInput, int nBytes,        /* String to be tokenized */
sqlite3_tokenizer_cursor **ppCursor    /* OUT: Tokenization cursor */
){
cus_tokenizer_cursor *c;
if(pInput == 0){
    nBytes = 0;
}else if(nBytes < 0)
     nBytes = (int)strlen(pInput);

c = (cus_tokenizer_cursor *) sqlite3_malloc(sizeof(*c));
if(c == NULL)
      return SQLITE_NOMEM;

c->iToken = c->nBytes = 0;
c->pInput = c->pToken = NULL;
c->pAlgor = mmseg_algor_create(pInput, nBytes);
c->nBytes = nBytes;
*ppCursor = &c->base;
return SQLITE_OK;
}

static int cusClose(sqlite3_tokenizer_cursor *pCursor){
cus_tokenizer_cursor *c = (cus_tokenizer_cursor *) pCursor;
if(c->pInput != NULL){
    sqlite3_free(c->pInput);
}
if(c->pToken != NULL){
    sqlite3_free(c->pToken);
}
if(c->pAlgor != NULL){
    mmseg_algor_destroy(c->pAlgor);
}
c->pInput = c->pToken = NULL;
c->pAlgor = NULL;
sqlite3_free(c);
return SQLITE_OK;
}

/*
1 sqlite只有在插入数据的时候才使用cursor遍历
2 在进行数据查询时，只会进入一次，然后使用piStartOffset与piEndOffset根据原始串重新生成查询串
*/
static int cusNext(
sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by cusOpen */
const char **ppToken,               /* OUT: *ppToken is the token text */
int *pnBytes,                       /* OUT: Number of bytes in token */
int *piStartOffset,                 /* OUT: Starting offset of token */
int *piEndOffset,                   /* OUT: Ending offset of token */
int *piPosition                     /* OUT: Position integer of token */
){
cus_tokenizer_cursor *c = (cus_tokenizer_cursor *) pCursor;
cus_tokenizer *t = (cus_tokenizer *) pCursor->pTokenizer;
if(c->pToken != NULL){
    sqlite3_free(c->pToken);
    c->pToken = NULL;
}
struct Token token = mmseg_next_token(c->pAlgor);
if(token.length != 0 ){
    int l = token.length;
    c->pToken = (char *)sqlite3_malloc(l+1);
    if(c->pToken == NULL)
        return SQLITE_NOMEM;
    c->pToken[l] = 0;
    memcpy(c->pToken, token.text, l);
    *ppToken = c->pToken;
    *pnBytes = l;
    *piStartOffset = token.offset;
    *piEndOffset = token.offset + token.length;
    *piPosition = c->iToken++;
    return SQLITE_OK;
}
//一般来说只有插入数据时才会进入到这里
return SQLITE_DONE;
}
static const sqlite3_tokenizer_module cusTokenizerModule = {
0,
cusCreate,
cusDestroy,
cusOpen,
cusClose,
cusNext,
};

int registerTokenizer(
        sqlite3 *db,
        char *zName,
        const sqlite3_tokenizer_module *p
        ){
    int rc;
    sqlite3_stmt *pStmt;
    const char *zSql = "SELECT fts3_tokenizer(?, ?)";
    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
    if( rc!=SQLITE_OK ){
        return rc;
    }
    sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
    sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
    sqlite3_step(pStmt);
    return sqlite3_finalize(pStmt);
}

int main(){
    const sqlite3_tokenizer_module *ptr = &cusTokenizerModule;
    sqlite3 *pDB;
    sqlite3_stmt * stmt;
    char * errMsg = NULL;
    const char *zTail;

    int rc = sqlite3_open("test.sqlite3", &pDB);
    if(rc){
        printf("create error. %s\n",sqlite3_errmsg(pDB));
        return rc;
    }
    char token_name[] = "custoken";
    registerTokenizer(pDB, token_name, ptr);

    rc = sqlite3_exec(pDB, "CREATE VIRTUAL TABLE foo USING fts3(tokenize=custoken)", 0, 0, &errMsg);
    if(rc != SQLITE_OK){
        printf("create virtual error, %s\n", errMsg);
    if(rc != SQLITE_OK){
        printf("create virtual error, %s\n", errMsg);
        return rc;
    }
    rc = sqlite3_exec(pDB, "INSERT INTO foo VALUES('\xe5\x8c\x97\xe4\xba\xac\xe5\xb8\x82')", 0, 0, &errMsg);
    if(rc != SQLITE_OK){
        printf("insert value error, %s\n", errMsg);
        return rc;
    }
    int nrow = 0, ncolumn = 0;
    char **azResult; //二维数组存放结果
    sqlite3_get_table(pDB , "SELECT * FROM foo WHERE content MATCH '\xe5\x8c\x97\xe4\xba\xac\xe5\xb8\x82'" , &azResult , &nrow , &ncolumn , &errMsg );
    int i = 0 ;
    printf( "row:%d column=%d \n" , nrow , ncolumn );
    printf( "\nThe result of querying is : \n" );
    for( i=0 ; i<( nrow + 1 ) * ncolumn ; i++ )
          printf( "azResult[%d] = %s\n", i , azResult[i] );
    sqlite3_free_table( azResult );
    sqlite3_close(pDB);
    return 0;
}

摘自：http://hi.baidu.com/xjtukanif/blog/item/8e7a4ea5362abf99d14358e2.html

[转载]delphi中register, pascal, cdecl, stdcall, safecall

原文地址：delphi中register, pascal, cdecl, stdcall, safecall作者：坚如磐石

注： 使用错误，或者在该加的地方没有加，可能会出现"privileged instruction"错误，或者地址访问错误。

常见的调用惯例有register, pascal, cdecl, stdcall, safecall。函数的调用管理决定了参数如何传递给子过程，并从堆栈中退出，以及寄存器在参数传递中的使用，错误和异常的处理。Delphi中默认的调用惯例是register。
1) register和pascal：参数从左向右传递，也就是说最左边的参数最先求值并传入，最右边的参数最后求值和传入。cdecl，stdcall和safecall则按从右向左方向。
2) 对于除cdecl之外的所有调用惯例，函数/过程在返回的时候要把堆栈中的参数退栈。对cdecl惯例，调用者在被调用的过程返回后执行参数退栈操作
3) register调用惯例最多能用3个CPU寄存器来传递参数，而其它调用惯例只能通过堆栈来传递参数
4) safecall调用惯例实现了异常的防火墙。在Windows上实现了跨进程的COM错误通知机制。
5) register调用效率最高，因为它避免了堆栈的创建。Delphi中published属性必须是register。
6) cdecl常用于调用C/C++编写的共享库中的函数；但是，如果要调用外部代码，那么一般要用stdcall和safecall
7) 在Windows上，系统的API都是stdcall和safecall；在其它操作系统上通常用cdecl（注意：stdcall比cdecl效率要高）
8) 在dual-interface（双接口）方法中必须用safecall惯例。
9) pascal惯例是为了向后兼容；near/far/export用于16位Window编程中的函数调用，在32位的应用程序中不发挥作用，仅仅是为了向后兼容。
下表进行了总结：

Calling conventions Parameter order Clean-up Passes parameters in registers？
register Left-to-right Routine Yes
pascal Left-to-right Routine No
cdecl Right-to-left Caller No
stdcall Right-to-left Routine No
safecall Right-to-left Routine No

参考资料：Delphi帮助文档

摘自：http://blog.sina.com.cn/s/blog_9048a0c40100uin9.html