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

/* * Returns value for the column at position iCol (starting from 0). * Reads column data from ref-values table, filtered by ObjectID and sorted by PropertyID * For the sake of better performance, fetches required columns on demand, sequentially. * */static int _column(sqlite3_vtab_cursor *pCursor, sqlite3_context *pContext, int iCol){    int result = SQLITE_OK;    struct flexi_VTabCursor *cur = (void *) pCursor;    if (iCol == -1)    {        sqlite3_result_int64(pContext, cur->lObjectID);        goto EXIT;    }    struct flexi_ClassDef_t *vtab = (void *) cur->base.pVtab;    // First, check if column has been already loaded    while (cur->iReadCol < iCol)    {        int colResult = sqlite3_step(cur->pPropertyIterator);        if (colResult == SQLITE_DONE)            break;        if (colResult != SQLITE_ROW)        {            result = colResult;            goto ONERROR;        }        sqlite3_int64 lPropID = sqlite3_column_int64(cur->pPropertyIterator, 1);        if (lPropID < vtab->pProps[cur->iReadCol + 1].iPropID)            continue;        cur->iReadCol++;        if (lPropID == vtab->pProps[cur->iReadCol].iPropID)        {            sqlite3_int64 lPropIdx = sqlite3_column_int64(cur->pPropertyIterator, 2);            /*             * No need in any special verification as we expect columns are sorted by property IDs, so             * we just assume that once column index is OK, we can process this property data             */            cur->pCols[cur->iReadCol] = sqlite3_value_dup(sqlite3_column_value(cur->pPropertyIterator, 4));        }    }    if (cur->pCols[iCol] == NULL || sqlite3_value_type(cur->pCols[iCol]) == SQLITE_NULL)    {        sqlite3_result_value(pContext, vtab->pProps[iCol].defaultValue);    }    else    {        sqlite3_result_value(pContext, cur->pCols[iCol]);    }    result = SQLITE_OK;    goto EXIT;    ONERROR:    EXIT:    // Map column number to property ID    return result;}

/*** Retrieve a column of data.*/static int schemaColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){  schema_cursor *pCur = (schema_cursor *)cur;  switch( i ){    case 0:      sqlite3_result_value(ctx, sqlite3_column_value(pCur->pDbList, 1));      break;    case 1:      sqlite3_result_value(ctx, sqlite3_column_value(pCur->pTableList, 0));      break;    default:      sqlite3_result_value(ctx, sqlite3_column_value(pCur->pColumnList, i-2));      break;  }  return SQLITE_OK;}

/*** EXPERIMENTAL - This is not an official function.  The interface may** change.  This function may disappear.  Do not write code that depends** on this function.**** Implementation of the QUOTE() function.  This function takes a single** argument.  If the argument is numeric, the return value is the same as** the argument.  If the argument is NULL, the return value is the string** "NULL".  Otherwise, the argument is enclosed in single quotes with** single-quote escapes.*/static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){  assert( argc==1 );  UNUSED_PARAMETER(argc);  switch( sqlite3_value_type(argv[0]) ){    case SQLITE_INTEGER:    case SQLITE_FLOAT: {      sqlite3_result_value(context, argv[0]);      break;    }    case SQLITE_BLOB: {      char *zText = 0;      char const *zBlob = sqlite3_value_blob(argv[0]);      int nBlob = sqlite3_value_bytes(argv[0]);      assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */      zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4);       if( zText ){        int i;        for(i=0; i<nBlob; i++){          zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];          zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];        }        zText[(nBlob*2)+2] = '/'';        zText[(nBlob*2)+3] = '/0';        zText[0] = 'X';        zText[1] = '/'';        sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);        sqlite3_free(zText);      }      break;    }    case SQLITE_TEXT: {      int i,j;      u64 n;      const unsigned char *zArg = sqlite3_value_text(argv[0]);      char *z;      if( zArg==0 ) return;      for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='/'' ) n++; }      z = contextMalloc(context, ((i64)i)+((i64)n)+3);      if( z ){        z[0] = '/'';        for(i=0, j=1; zArg[i]; i++){          z[j++] = zArg[i];          if( zArg[i]=='/'' ){            z[j++] = '/'';          }        }        z[j++] = '/'';        z[j] = 0;        sqlite3_result_text(context, z, j, sqlite3_free);      }      break;    }    default: {      assert( sqlite3_value_type(argv[0])==SQLITE_NULL );      sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);      break;    }  }}

static int sesqlite_column(sqlite3_vtab_cursor *cur, sqlite3_context *ctx,		int cidx) {	sesqlite_cursor *c = (sesqlite_cursor*) cur;	sqlite3_result_value(ctx, sqlite3_column_value(c->stmt, cidx));	return SQLITE_OK;}

/*** Invoke an SQL statement recursively.  The function result is the ** first column of the first row of the result set.*/static void test_eval(  sqlite3_context *pCtx,   int nArg,  sqlite3_value **argv){  sqlite3_stmt *pStmt;  int rc;  sqlite3 *db = sqlite3_context_db_handle(pCtx);  const char *zSql;  zSql = (char*)sqlite3_value_text(argv[0]);  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);  if( rc==SQLITE_OK ){    rc = sqlite3_step(pStmt);    if( rc==SQLITE_ROW ){      sqlite3_result_value(pCtx, sqlite3_column_value(pStmt, 0));    }    rc = sqlite3_finalize(pStmt);  }  if( rc ){    char *zErr;    assert( pStmt==0 );    zErr = sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db));    sqlite3_result_text(pCtx, zErr, -1, sqlite3_free);    sqlite3_result_error_code(pCtx, rc);  }}

/*** Implementation of the non-aggregate min() and max() functions*/static void minmaxFunc(  sqlite3_context *context,  int argc,  sqlite3_value **argv){  int i;  int mask;    /* 0 for min() or 0xffffffff for max() */  int iBest;  CollSeq *pColl;  if( argc==0 ) return;  mask = sqlite3_user_data(context)==0 ? 0 : -1;  pColl = sqlite3GetFuncCollSeq(context);  assert( pColl );  assert( mask==-1 || mask==0 );  iBest = 0;  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;  for(i=1; i<argc; i++){    if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;    if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){      iBest = i;    }  }  sqlite3_result_value(context, argv[iBest]);}

void __SQLite3ExtLogicFunctionIf(sqlite3_context *context, int argc, sqlite3_value **argv) {  if (argc == 3) {    sqlite3_result_value(context, sqlite3_value_int(argv[0]) ? argv[1] : argv[2]);  } else {    sqlite3_result_null(context);  }}

/*** EXPERIMENTAL - This is not an official function.  The interface may** change.  This function may disappear.  Do not write code that depends** on this function.**** Implementation of the QUOTE() function.  This function takes a single** argument.  If the argument is numeric, the return value is the same as** the argument.  If the argument is NULL, the return value is the string** "NULL".  Otherwise, the argument is enclosed in single quotes with** single-quote escapes.*/static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv) {    if( argc<1 ) return;    switch( sqlite3_value_type(argv[0]) ) {    case SQLITE_NULL: {        sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);        break;    }    case SQLITE_INTEGER:    case SQLITE_FLOAT: {        sqlite3_result_value(context, argv[0]);        break;    }    case SQLITE_BLOB: {        char *zText = 0;        int nBlob = sqlite3_value_bytes(argv[0]);        char const *zBlob = sqlite3_value_blob(argv[0]);        zText = (char *)sqliteMalloc((2*nBlob)+4);        if( !zText ) {            sqlite3_result_error(context, "out of memory", -1);        } else {            int i;            for(i=0; i<nBlob; i++) {                zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];                zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];            }            zText[(nBlob*2)+2] = '/'';            zText[(nBlob*2)+3] = '/0';            zText[0] = 'X';            zText[1] = '/'';            sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);            sqliteFree(zText);        }        break;    }    case SQLITE_TEXT: {        int i,j,n;        const unsigned char *zArg = sqlite3_value_text(argv[0]);        char *z;        for(i=n=0; zArg[i]; i++) {            if( zArg[i]=='/'' ) n++;        }        z = sqliteMalloc( i+n+3 );        if( z==0 ) return;        z[0] = '/'';        for(i=0, j=1; zArg[i]; i++) {            z[j++] = zArg[i];            if( zArg[i]=='/'' ) {                z[j++] = '/'';            }        }        z[j++] = '/'';        z[j] = 0;        sqlite3_result_text(context, z, j, SQLITE_TRANSIENT);        sqliteFree(z);    }    }}

static void minMaxFinalize(sqlite3_context *context){  sqlite3_value *pRes;  pRes = (sqlite3_value *)sqlite3_aggregate_context(context, sizeof(Mem));  if( pRes->flags ){    sqlite3_result_value(context, pRes);  }  sqlite3VdbeMemRelease(pRes);}

/*** Implementation of the NULLIF(x,y) function.  The result is the first** argument if the arguments are different.  The result is NULL if the** arguments are equal to each other.*/static void nullifFunc(  sqlite3_context *context,  int argc,  sqlite3_value **argv){  CollSeq *pColl = sqlite3GetFuncCollSeq(context);  if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){    sqlite3_result_value(context, argv[0]);  }}

/*** Implementation of the NULLIF(x,y) function.  The result is the first** argument if the arguments are different.  The result is NULL if the** arguments are equal to each other.*/static void nullifFunc(  sqlite3_context *context,  int NotUsed,  sqlite3_value **argv){  CollSeq *pColl = sqlite3GetFuncCollSeq(context);  UNUSED_PARAMETER(NotUsed);  if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){    sqlite3_result_value(context, argv[0]);  }}

ikptrik_sqlite3_result_value (ikptr s_context, ikptr s_retval, ikpcb * pcb){#ifdef HAVE_SQLITE3_RESULT_VALUE  sqlite3_context *	context = IK_SQLITE_CONTEXT(s_context);  sqlite3_value *	retval  = IK_SQLITE_VALUE(s_retval);  sqlite3_result_value(context, retval);  return IK_VOID_OBJECT;#else  feature_failure(__func__);#endif}

/*** Implementation of the IFNULL(), NVL(), and COALESCE() functions.  ** All three do the same thing.  They return the first non-NULL** argument.*/static void ifnullFunc(  sqlite3_context *context,  int argc,  sqlite3_value **argv){  int i;  for(i=0; i<argc; i++){    if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){      sqlite3_result_value(context, argv[i]);      break;    }  }}

/*** This function takes two arguments.  It performance UTF-8/16 type** conversions on the first argument then returns a copy of the second** argument.**** This function is used in cases such as the following:****      SELECT test_isolation(x,x) FROM t1;**** We want to verify that the type conversions that occur on the** first argument do not invalidate the second argument.*/static void test_isolation(  sqlite3_context *pCtx,   int nArg,  sqlite3_value **argv){#ifndef SQLITE_OMIT_UTF16  sqlite3_value_text16(argv[0]);  sqlite3_value_text(argv[0]);  sqlite3_value_text16(argv[0]);  sqlite3_value_text(argv[0]);#endif  sqlite3_result_value(pCtx, argv[1]);}

/*** Return values of columns for the row at which the explain_cursor** is currently pointing.*/static int explainColumn(  sqlite3_vtab_cursor *cur,   /* The cursor */  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */  int i                       /* Which column to return */){  explain_cursor *pCur = (explain_cursor*)cur;  if( i==EXPLN_COLUMN_SQL ){    sqlite3_result_text(ctx, pCur->zSql, -1, SQLITE_TRANSIENT);  }else{    sqlite3_result_value(ctx, sqlite3_column_value(pCur->pExplain, i));  }  return SQLITE_OK;}

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]);	}}

static int echoColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){  int iCol = i + 1;  sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;  if( simulateVtabError((echo_vtab *)(cur->pVtab), "xColumn") ){    return SQLITE_ERROR;  }  if( !pStmt ){    sqlite3_result_null(ctx);  }else{    assert( sqlite3_data_count(pStmt)>iCol );    sqlite3_result_value(ctx, sqlite3_column_value(pStmt, iCol));  }  return SQLITE_OK;}

static void mmenc_func(sqlite3_context *db, int argc, sqlite3_value **argv){    mm_cipher_context_t *ctx;    const UChar *src;    int32_t src_len;    char buf[1024];    char *dst = buf;    int32_t dst_len;    UErrorCode status = U_ZERO_ERROR;    int arg_type;    // only accept 1 argument.    if (argc != 1)        goto error_misuse;    // encoding BLOB data type is not supported.    arg_type = sqlite3_value_type(argv[0]);    if (arg_type == SQLITE_BLOB)        goto error_misuse;    // for data types other than TEXT, just return them.    if (arg_type != SQLITE_TEXT) {        sqlite3_result_value(db, argv[0]);        return;    }    ctx = (mm_cipher_context_t *) sqlite3_user_data(db);    src_len = sqlite3_value_bytes16(argv[0]) / 2;    src = (const UChar *) sqlite3_value_text16(argv[0]);    // transform input string to BOCU-1 encoding.    // try stack buffer first, if it doesn't fit, malloc a new buffer.    dst_len =        ucnv_fromUChars(ctx->cnv, dst, sizeof(buf), src, src_len, &status);    if (status == U_BUFFER_OVERFLOW_ERROR) {        status = U_ZERO_ERROR;        dst = (char *) sqlite3_malloc(dst_len);        dst_len =            ucnv_fromUChars(ctx->cnv, dst, dst_len, src, src_len, &status);    }    if (U_FAILURE(status) && status != U_STRING_NOT_TERMINATED_WARNING) {        sqlite3_mm_set_last_error(            "Failed transforming text to internal encoding.");        goto error_error;    }    // encrypt transformed BOCU-1 string.    do_rc4(ctx, dst, dst_len);    // return    sqlite3_result_blob(db, dst, dst_len, SQLITE_TRANSIENT);    if (dst != buf)        sqlite3_free(dst);    return;error_error:    if (dst != buf)        sqlite3_free(dst);    sqlite3_result_error_code(db, SQLITE_ERROR);    return;error_misuse:    if (dst != buf)        sqlite3_free(dst);    sqlite3_result_error_code(db, SQLITE_MISUSE);    return;}

/*** The replace() function.  Three arguments are all strings: call** them A, B, and C. The result is also a string which is derived** from A by replacing every occurance of B with C.  The match** must be exact.  Collating sequences are not used.*/static void replaceFunc(  sqlite3_context *context,  int argc,  sqlite3_value **argv){  const unsigned char *zStr;        /* The input string A */  const unsigned char *zPattern;    /* The pattern string B */  const unsigned char *zRep;        /* The replacement string C */  unsigned char *zOut;              /* The output */  int nStr;                /* Size of zStr */  int nPattern;            /* Size of zPattern */  int nRep;                /* Size of zRep */  i64 nOut;                /* Maximum size of zOut */  int loopLimit;           /* Last zStr[] that might match zPattern[] */  int i, j;                /* Loop counters */  assert( argc==3 );  UNUSED_PARAMETER(argc);  zStr = sqlite3_value_text(argv[0]);  if( zStr==0 ) return;  nStr = sqlite3_value_bytes(argv[0]);  assert( zStr==sqlite3_value_text(argv[0]) );  /* No encoding change */  zPattern = sqlite3_value_text(argv[1]);  if( zPattern==0 ){    assert( sqlite3_value_type(argv[1])==SQLITE_NULL            || sqlite3_context_db_handle(context)->mallocFailed );    return;  }  if( zPattern[0]==0 ){    assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );    sqlite3_result_value(context, argv[0]);    return;  }  nPattern = sqlite3_value_bytes(argv[1]);  assert( zPattern==sqlite3_value_text(argv[1]) );  /* No encoding change */  zRep = sqlite3_value_text(argv[2]);  if( zRep==0 ) return;  nRep = sqlite3_value_bytes(argv[2]);  assert( zRep==sqlite3_value_text(argv[2]) );  nOut = nStr + 1;  assert( nOut<SQLITE_MAX_LENGTH );  zOut = contextMalloc(context, (i64)nOut);  if( zOut==0 ){    return;  }  loopLimit = nStr - nPattern;    for(i=j=0; i<=loopLimit; i++){    if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){      zOut[j++] = zStr[i];    }else{      u8 *zOld;      sqlite3 *db = sqlite3_context_db_handle(context);      nOut += nRep - nPattern;      testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );      testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );      if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){        sqlite3_result_error_toobig(context);        sqlite3DbFree(db, zOut);        return;      }      zOld = zOut;      zOut = sqlite3_realloc(zOut, (int)nOut);      if( zOut==0 ){        sqlite3_result_error_nomem(context);        sqlite3DbFree(db, zOld);        return;      }      memcpy(&zOut[j], zRep, nRep);      j += nRep;      i += nPattern-1;    }  }  assert( j+nStr-i+1==nOut );  memcpy(&zOut[j], &zStr[i], nStr-i);  j += nStr - i;  assert( j<=nOut );  zOut[j] = 0;  sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);}

//.........这里部分代码省略.........    }    if (sqlite3_value_type (argv[3]) == SQLITE_FLOAT)    {	y_coord = sqlite3_value_double (argv[3]);    }    else if (sqlite3_value_type (argv[3]) == SQLITE_INTEGER)    {	int_value = sqlite3_value_int (argv[3]);	y_coord = int_value;    }    else    {	sqlite3_result_error(context, "gpkgPointToTile() error: argument 4 [y coordinate] is not of a numerical type", -1);	return;    }        if (sqlite3_value_type (argv[4]) != SQLITE_INTEGER)    {	sqlite3_result_error(context, "gpkgPointToTile() error: argument 5 [zoom level] is not of the integer type", -1);	return;    }    zoom = sqlite3_value_int (argv[4]);        /* project into right coordinate basis if the input isn't already there */    /* Get the target table SRID */    sql_stmt = sqlite3_mprintf("SELECT srid FROM raster_columns WHERE r_table_name=%Q AND r_raster_column='tile_data'", table);    sqlite = sqlite3_context_db_handle (context);    ret = sqlite3_prepare_v2 (sqlite, sql_stmt, strlen(sql_stmt), &stmt, NULL);    sqlite3_free(sql_stmt);    if (ret != SQLITE_OK)    {	sqlite3_result_error(context, "gpkgPointToTile() error: failed to prepare SQL SRID select statement", -1);        return;    }    ret = sqlite3_step (stmt);    if (ret != SQLITE_ROW)    {	sqlite3_finalize (stmt);	sqlite3_result_error(context, "gpkgPointToTile() error: Could not find SRID for specified table", -1);        return;    }    if (sqlite3_column_type (stmt, 0) != SQLITE_INTEGER)    {	sqlite3_finalize (stmt);	sqlite3_result_error(context, "gpkgPointToTile() error: SRID for table is not an integer. Corrupt GeoPackage?", -1);	return;    }    target_srid = sqlite3_column_int(stmt, 0);    sqlite3_finalize (stmt);        if (srid != target_srid)    {	/* project input coordinates */	sql_stmt = sqlite3_mprintf("SELECT ST_X(projected),ST_Y(projected) FROM (SELECT Transform(MakePoint(%f, %f, %i), %i) AS projected)",				   x_coord, y_coord, srid, target_srid);	sqlite = sqlite3_context_db_handle (context);	ret = sqlite3_prepare_v2 (sqlite, sql_stmt, strlen(sql_stmt), &stmt, NULL);	sqlite3_free(sql_stmt);	if (ret != SQLITE_OK)	{	    sqlite3_result_error(context, "gpkgPointToTile() error: failed to prepare SQL Transform statement", -1);	    return;	}	ret = sqlite3_step (stmt);	if (ret == SQLITE_ROW)	{	    if ((sqlite3_column_type (stmt, 0) == SQLITE_FLOAT) && (sqlite3_column_type (stmt, 1) == SQLITE_FLOAT))	    {		x_coord = sqlite3_column_double(stmt, 0);		y_coord = sqlite3_column_double(stmt, 1);	    }	}	ret = sqlite3_finalize (stmt);    }        /* now we can get the tile blob */    sql_stmt = sqlite3_mprintf("SELECT tile_data FROM /"%q/",/"%s_rt_metadata/" WHERE %q.id=%s_rt_metadata.id AND zoom_level=%i AND min_x <= %g AND max_x >=%g AND min_y <= %g AND max_y >= %g",			table, table, table, table, zoom, x_coord, x_coord, y_coord, y_coord);    sqlite = sqlite3_context_db_handle (context);    ret = sqlite3_prepare_v2 (sqlite, sql_stmt, strlen(sql_stmt), &stmt, NULL);    sqlite3_free(sql_stmt);    if (ret != SQLITE_OK)    {	sqlite3_result_error(context, "gpkgPointToTile() error: failed to prepare SQL statement", -1);        return;    }    ret = sqlite3_step (stmt);    if (ret == SQLITE_ROW)    {	if (sqlite3_column_type (stmt, 0) == SQLITE_BLOB)	{	    sqlite3_result_value (context, sqlite3_column_value(stmt, 0));	}    }    ret = sqlite3_finalize (stmt);}

 void context::result_copy(int idx) {   sqlite3_result_value(ctx_, values_[idx]); }