自学教程：C++ sqlite3_value_type函数代码示例

/*** Implementation of the upper() and lower() SQL functions.*/static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){  unsigned char *z;  int i;  if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;  z = sqliteMalloc(sqlite3_value_bytes(argv[0])+1);  if( z==0 ) return;  strcpy(z, sqlite3_value_text(argv[0]));  for(i=0; z[i]; i++){    z[i] = toupper(z[i]);  }  sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT);  sqliteFree(z);}

static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){  int n = 0;  double r;  char *zBuf;  assert( argc==1 || argc==2 );  if( argc==2 ){    if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;    n = sqlite3_value_int(argv[1]);    if( n>30 ) n = 30;    if( n<0 ) n = 0;  }  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;  r = sqlite3_value_double(argv[0]);  zBuf = sqlite3_mprintf("%.*f",n,r);  if( zBuf==0 ){    sqlite3_result_error_nomem(context);  }else{    sqlite3AtoF(zBuf, &r);    sqlite3_free(zBuf);    sqlite3_result_double(context, r);  }}

staticvoid OGR2SQLITE_ogr_SetConfigOption(sqlite3_context* pContext,                            int argc, sqlite3_value** argv){    if( sqlite3_value_type (argv[0]) != SQLITE_TEXT )    {        sqlite3_result_null (pContext);        return;    }    if( sqlite3_value_type (argv[1]) != SQLITE_TEXT &&        sqlite3_value_type (argv[1]) != SQLITE_NULL )    {        sqlite3_result_null (pContext);        return;    }    const char* pszKey = (const char*)sqlite3_value_text(argv[0]);    const char* pszVal = (sqlite3_value_type (argv[1]) == SQLITE_TEXT) ?        (const char*)sqlite3_value_text(argv[1]) : NULL;    CPLSetConfigOption(pszKey, pszVal);    sqlite3_result_null (pContext);}

/* wrapper for Jaro-Winkler string comparison */void jarowinkler_wrapper(sqlite3_context *ctx, int n_values, sqlite3_value **value){	// check for NULL values, return NULL if any of the input strings is NULL	if(sqlite3_value_type(value[0]) == SQLITE_NULL ||   	 sqlite3_value_type(value[1]) == SQLITE_NULL)  {		sqlite3_result_null(ctx);		return;	}  const unsigned char *str1 = sqlite3_value_text(value[0]);  const unsigned char *str2 = sqlite3_value_text(value[1]);	#ifdef DEBUG 	  Rprintf("String 1: %s/n", str1);		Rprintf("String 2: %s/n", str2);	#endif  double result;  result = jarowinkler_core(str1, str2, 1.0/3, 1.0/3, 1.0/3, 0.5);	#ifdef DEBUG  	Rprintf("Ergebnis des Stringvergleichs: %f/n", result);  #endif  sqlite3_result_double(ctx, result);}

static voidxmms_sqlite_stringify (sqlite3_context *context, int args, sqlite3_value **val){	gint i;	gchar buffer[32];	if (sqlite3_value_type (val[0]) == SQLITE_INTEGER) {		i = sqlite3_value_int (val[0]);		sprintf (buffer, "%d", i);		sqlite3_result_text (context, buffer, -1, SQLITE_TRANSIENT);	} else {		sqlite3_result_value (context, val[0]);	}}

staticvoid OGR2SQLITE_ST_GeomFromText(sqlite3_context* pContext,                                int argc, sqlite3_value** argv){    if( sqlite3_value_type (argv[0]) != SQLITE_TEXT )    {        sqlite3_result_null (pContext);        return;    }    char* pszWKT = (char*) sqlite3_value_text( argv[0] );    int nSRID = -1;    if( argc == 2 && sqlite3_value_type (argv[1]) == SQLITE_INTEGER )        nSRID = sqlite3_value_int( argv[1] );    OGRGeometry* poGeom = NULL;    if( OGRGeometryFactory::createFromWkt(&pszWKT, NULL, &poGeom) == OGRERR_NONE )    {        OGR2SQLITE_SetGeom_AndDestroy(pContext, poGeom, nSRID);    }    else        sqlite3_result_null (pContext);}

extern void pg_bool_or_step(sqlite3_context *context,                            int              argc,                            sqlite3_value  **argv) {  CONTEXT_T *ctx;  int        typ;  int        val;  typ = sqlite3_value_type(argv[0]);  if (typ != SQLITE_NULL) {    if (typ == SQLITE_INTEGER) {      val = sqlite3_value_int(argv[0]);      if ((val != 0) && (val != 1)) {        ksu_err_msg(context, KSU_ERR_INV_DATATYPE, "bool_or");        return;      }    } else {      char *p = (char *)sqlite3_value_text(argv[0]);      int   len = strlen(p);      if (len == 1) {        if (toupper(*p) == 'T') {          val = 1;        } else if (toupper(*p) == 'F') {          val = 0;        } else {          ksu_err_msg(context, KSU_ERR_INV_DATATYPE, "bool_or");          return;        }      } else if (strcasecmp(p, "true") == 0) {        val = 1;      } else if (strcasecmp(p, "false") == 0) {        val = 0;      } else {        ksu_err_msg(context, KSU_ERR_INV_DATATYPE, "bool_or");        return;      }    }    val = sqlite3_value_int64(argv[0]);    ctx = (CONTEXT_T *)sqlite3_aggregate_context(context, sizeof(CONTEXT_T));    if (ctx) {      if (ctx->n == 0) {        ctx->boolval = val;      } else {        ctx->boolval |= val;      }      (ctx->n)++;    }  }}

/*** Return the type of the argument.*/static void typeofFunc(  sqlite3_context *context,  int argc,  sqlite3_value **argv){  const char *z = 0;  switch( sqlite3_value_type(argv[0]) ){    case SQLITE_NULL:    z = "null";    break;    case SQLITE_INTEGER: z = "integer"; break;    case SQLITE_TEXT:    z = "text";    break;    case SQLITE_FLOAT:   z = "real";    break;    case SQLITE_BLOB:    z = "blob";    break;  }  sqlite3_result_text(context, z, -1, SQLITE_STATIC);}

staticvoid OGR2SQLITE_ogr_version(sqlite3_context* pContext,                            int argc, sqlite3_value** argv){    if( argc == 0 || sqlite3_value_type (argv[0]) != SQLITE_TEXT )    {        sqlite3_result_text( pContext, GDAL_RELEASE_NAME, -1, SQLITE_STATIC );    }    else    {        sqlite3_result_text( pContext,                             GDALVersionInfo((const char*)sqlite3_value_text(argv[0])),                             -1, SQLITE_TRANSIENT );    }}

static int dbpageUpdate(  sqlite3_vtab *pVtab,  int argc,  sqlite3_value **argv,  sqlite_int64 *pRowid){  DbpageTable *pTab = (DbpageTable *)pVtab;  int pgno;  DbPage *pDbPage = 0;  int rc = SQLITE_OK;  char *zErr = 0;  if( argc==1 ){    zErr = "cannot delete";    goto update_fail;  }  pgno = sqlite3_value_int(argv[0]);  if( pgno<1 || pgno>pTab->nPage ){    zErr = "bad page number";    goto update_fail;  }  if( sqlite3_value_int(argv[1])!=pgno ){    zErr = "cannot insert";    goto update_fail;  }  if( sqlite3_value_type(argv[3])!=SQLITE_BLOB    || sqlite3_value_bytes(argv[3])!=pTab->szPage   ){    zErr = "bad page value";    goto update_fail;  }  rc = sqlite3PagerGet(pTab->pPager, pgno, (DbPage**)&pDbPage, 0);  if( rc==SQLITE_OK ){    rc = sqlite3PagerWrite(pDbPage);    if( rc==SQLITE_OK ){      memcpy(sqlite3PagerGetData(pDbPage),             sqlite3_value_blob(argv[3]),             pTab->szPage);    }  }  sqlite3PagerUnref(pDbPage);  return rc;update_fail:  sqlite3_free(pVtab->zErrMsg);  pVtab->zErrMsg = sqlite3_mprintf("%s", zErr);  return SQLITE_ERROR;}

extern void my_radians(sqlite3_context * context,                        int               argc,                        sqlite3_value  ** argv) {   double val;   int    typ;   _ksu_null_if_null_param(argc, argv);   //Check whether the value is actually a number    typ = sqlite3_value_type(argv[0]);   if ((typ != SQLITE_INTEGER) && (typ != SQLITE_FLOAT)) {      sqlite3_result_int(context, 0);   } else {      val = sqlite3_value_double(argv[0]);      sqlite3_result_double(context, ((val * M_PI) / 180));   } } 

static void getUnicodeResult(const RtlFieldInfo *field, sqlite3_value *val, size32_t &chars, UChar * &result){    assertex(val);    if (isNull(val))    {        NullFieldProcessor p(field);        rtlUnicodeToUnicodeX(chars, result, p.resultChars, p.unicodeResult);        return;    }    if (sqlite3_value_type(val) != SQLITE_TEXT)        typeError("string", field);    const UChar *text = (const UChar *) sqlite3_value_text16(val);    int bytes = sqlite3_value_bytes16(val);    unsigned numchars = bytes / sizeof(UChar);    rtlUnicodeToUnicodeX(chars, result, numchars, text);}

static void getUTF8Result(const RtlFieldInfo *field, sqlite3_value *val, size32_t &chars, char * &result){    assertex(val);    if (isNull(val))    {        NullFieldProcessor p(field);        rtlUtf8ToUtf8X(chars, result, p.resultChars, p.stringResult);        return;    }    if (sqlite3_value_type(val) != SQLITE_TEXT)        typeError("string", field);    const char *text = (const char *) sqlite3_value_text(val);    int bytes = sqlite3_value_bytes(val);    unsigned numchars = rtlUtf8Length(bytes, text);    rtlUtf8ToUtf8X(chars, result, numchars, text);}

/*** Routines to implement the count() aggregate function.*/static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){  CountCtx *p;  p = sqlite3_aggregate_context(context, sizeof(*p));  if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){    p->n++;  }#ifndef SQLITE_OMIT_DEPRECATED  /* The sqlite3_aggregate_count() function is deprecated.  But just to make  ** sure it still operates correctly, verify that its count agrees with our   ** internal count when using count(*) and when the total count can be  ** expressed as a 32-bit integer. */  assert( argc==1 || p==0 || p->n>0x7fffffff          || p->n==sqlite3_aggregate_count(context) );#endif}   

static int fulltextUpdate(sqlite3_vtab *pVtab, int nArg, sqlite3_value **ppArg,                   sqlite_int64 *pRowid){  fulltext_vtab *v = (fulltext_vtab *) pVtab;  if( nArg<2 ){    return index_delete(v, sqlite3_value_int64(ppArg[0]));  }  if( sqlite3_value_type(ppArg[0]) != SQLITE_NULL ){    return SQLITE_ERROR;   /* an update; not yet supported */  }  assert( nArg==3 );    /* ppArg[1] = rowid, ppArg[2] = content */  return index_insert(v, ppArg[1],                      (const char *)sqlite3_value_text(ppArg[2]), pRowid);}

/*** Return the type of the argument.*/static void typeofFunc(  sqlite3_context *context,  int NotUsed,  sqlite3_value **argv){  const char *z = 0;  UNUSED_PARAMETER(NotUsed);  switch( sqlite3_value_type(argv[0]) ){    case SQLITE_INTEGER: z = "integer"; break;    case SQLITE_TEXT:    z = "text";    break;    case SQLITE_FLOAT:   z = "real";    break;    case SQLITE_BLOB:    z = "blob";    break;    default:             z = "null";    break;  }  sqlite3_result_text(context, z, -1, SQLITE_STATIC);}

static void utf8error(sqlite3_context *context, int argc, sqlite3_value **argv){    switch (sqlite3_value_type(argv[0]) ) {    case SQLITE_TEXT: {        const unsigned char *tVal = sqlite3_value_text(argv[0]);        if (g_utf8_validate((gchar *)tVal, -1, NULL))            sqlite3_result_int(context, 0);        else            sqlite3_result_int(context, 1);        break;    }    default:        sqlite3_result_null(context);        break;    }}

void lsqlite3lib_xstep_callback(sqlite3_context* ctx,int n, sqlite3_value** value) {	int i;	func* f = (func*)sqlite3_user_data(ctx);	conn* c = f->c;	int*  ref = sqlite3_aggregate_context(ctx, sizeof(int));	if(!ref) sqlite3_result_error_nomem(ctx);	if(*ref == 0) {		lua_newtable(c->L);		*ref = luaL_ref(c->L, LUA_REGISTRYINDEX);	}	lua_rawgeti(c->L, LUA_REGISTRYINDEX, c->ref);	lua_rawgeti(c->L, -1, IDX_FUNCTION_TABLE);	lua_pushstring(c->L, f->func_name);	lua_rawget(c->L, -2);	lua_rawgeti(c->L, -1, IDX_FUNC_XSTEP);	lua_createtable(c->L, n, 0);	for(i = 0; i < n; i++) {		lua_pushinteger(c->L, i + 1);		switch(sqlite3_value_type(*(value+i))) {		case SQLITE_INTEGER:			lua_pushinteger(c->L, sqlite3_value_int(*(value+i)));			break;		case SQLITE_FLOAT:			lua_pushnumber(c->L, sqlite3_value_double(*(value+i)));			break;		case SQLITE3_TEXT:			lua_pushstring(c->L, (const char*)sqlite3_value_text(*(value+i)));			break;		case SQLITE_BLOB:		case SQLITE_NULL:		default:			lua_pushnil(c->L);			break;		}		lua_rawset(c->L, -3);	}	lua_rawgeti(c->L, LUA_REGISTRYINDEX, *ref);	lua_call(c->L, 2, 0);}

staticvoid OGR2SQLITE_ogr_GetConfigOption(sqlite3_context* pContext,                                    int argc, sqlite3_value** argv){    if( sqlite3_value_type (argv[0]) != SQLITE_TEXT )    {        sqlite3_result_null (pContext);        return;    }    const char* pszKey = (const char*)sqlite3_value_text(argv[0]);    const char* pszVal = CPLGetConfigOption(pszKey, NULL);    if( pszVal == NULL )        sqlite3_result_null (pContext);    else        sqlite3_result_text( pContext, pszVal, -1, SQLITE_TRANSIENT );}

static double OGR2SQLITE_GetValAsDouble(sqlite3_value* val, int* pbGotVal){    switch(sqlite3_value_type(val))    {    case SQLITE_FLOAT:        if( pbGotVal ) *pbGotVal = TRUE;        return sqlite3_value_double(val);    case SQLITE_INTEGER:        if( pbGotVal ) *pbGotVal = TRUE;        return (double) sqlite3_value_int64(val);    default:        if( pbGotVal ) *pbGotVal = FALSE;        return 0.0;    }}

SQLITE_EXTENSION_INIT1#include <assert.h>#include <string.h>/*** Implementation of the ieee754() function*/static void ieee754func(  sqlite3_context *context,  int argc,  sqlite3_value **argv){  if( argc==1 ){    sqlite3_int64 m, a;    double r;    int e;    int isNeg;    char zResult[100];    assert( sizeof(m)==sizeof(r) );    if( sqlite3_value_type(argv[0])!=SQLITE_FLOAT ) return;    r = sqlite3_value_double(argv[0]);    if( r<0.0 ){      isNeg = 1;      r = -r;    }else{      isNeg = 0;    }    memcpy(&a,&r,sizeof(a));    if( a==0 ){      e = 0;      m = 0;    }else{      e = a>>52;      m = a & ((((sqlite3_int64)1)<<52)-1);      m |= ((sqlite3_int64)1)<<52;      while( e<1075 && m>0 && (m&1)==0 ){        m >>= 1;        e++;      }      if( isNeg ) m = -m;    }    sqlite3_snprintf(sizeof(zResult), zResult, "ieee754(%lld,%d)",                     m, e-1075);    sqlite3_result_text(context, zResult, -1, SQLITE_TRANSIENT);  }else if( argc==2 ){

SQLITE_EXTENSION_INIT1static void hunupper(sqlite3_context *ctx, int argc, sqlite3_value **argv){	const unsigned char *input;	int length, pos = 0;	unsigned char *result;	if (argc != 1) {		sqlite3_result_error(ctx, "invalid number of arguments", -1);		return;	}	if (sqlite3_value_type(argv[0]) == SQLITE_NULL) return;	input = (const unsigned char *) sqlite3_value_text(argv[0]);	if (!input) {		sqlite3_result_error(ctx, "no input specified", -1);		return;	}	length = strlen((const char*) input);	result = (unsigned char *)sqlite3_malloc(length);	if (!result) {		sqlite3_result_error(ctx, "cannot allocate result", -1);		return;	}	while (pos < length) {		result[pos] = input[pos] >= 'a' && input[pos] <= 'z' ? 0xDF & input[pos] : input[pos];		switch (input[pos++]) {			case 0xc3: /* á-a1>81 é-a9>89 í-ad>8d ó-b3>93 
C++ sqlite3_vfs_find函数代码示例
C++ sqlite3_value_text函数代码示例