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

extern void pg_covar_step(sqlite3_context *context,                          int              argc,                          sqlite3_value  **argv) {  COVAR_CONTEXT_T *ctx;  int        typ1;  int        typ2;  double     val1;  double     val2;  if (((typ1 = sqlite3_value_type(argv[0])) != SQLITE_NULL)      && ((typ2 = sqlite3_value_type(argv[1])) != SQLITE_NULL)) {    if (ksu_prm_ok(context, argc, argv, "covar",                   KSU_PRM_NUMERIC, KSU_PRM_NUMERIC)) {      ctx = (COVAR_CONTEXT_T *)sqlite3_aggregate_context(context,                            sizeof(COVAR_CONTEXT_T));      val1 = sqlite3_value_double(argv[0]);      val2 = sqlite3_value_double(argv[1]);      if (ctx) {        ctx->sum1 += val1;        ctx->sum2 += val2;        ctx->sum_prod += (val1 * val2);        (ctx->n)++;      }    }  }}

static void distanceFunc(sqlite3_context *context, int argc, sqlite3_value **argv) {	// check that we have four arguments (lat1, lon1, lat2, lon2)	assert(argc == 4);	// check that all four arguments are non-null	if (sqlite3_value_type(argv[0]) == SQLITE_NULL ||	 sqlite3_value_type(argv[1]) == SQLITE_NULL ||	  sqlite3_value_type(argv[2]) == SQLITE_NULL ||	   sqlite3_value_type(argv[3]) == SQLITE_NULL) {		sqlite3_result_null(context);		return;	}	// get the four argument values	double lat1 = sqlite3_value_double(argv[0]);	double lon1 = sqlite3_value_double(argv[1]);	double lat2 = sqlite3_value_double(argv[2]);	double lon2 = sqlite3_value_double(argv[3]);	// convert lat1 and lat2 into radians now, to avoid doing it twice below	double lat1rad = DEG2RAD(lat1);	double lat2rad = DEG2RAD(lat2);	// apply the spherical law of cosines to our latitudes and longitudes, and set the result appropriately	// 6378.1 is the approximate radius of the earth in kilometres	sqlite3_result_double(context, acos(sin(lat1rad) * sin(lat2rad) + cos(lat1rad) * cos(lat2rad) * cos(DEG2RAD(lon2) - DEG2RAD(lon1))) * 6378.1);}

void collisionFunctionForSqlite(sqlite3_context* context, int dunno, sqlite3_value** values) {  Number x(sqlite3_value_double(values[0])), z(sqlite3_value_double(values[1]));  Number distance_sq = FixedPoint::square(collider_x - x)                     + FixedPoint::square(collider_z - z);  sqlite3_result_int(context,                     distance_sq < collider_rsq ? 1 : 0);  ++collider_comparisons;}

void geo_bound(sqlite3_context *context,int argc,sqlite3_value **argv){	if(argc >= 1)	{		const unsigned char* ogc;		unsigned char* ret_geo_buf;		size_t size;		double x1,x2,y1,y2;		GEOSCoordSequence* seq = 0;		GEOSGeometry* geometry = 0;		GEOSGeometry* middle_geo = 0;				_init_geos();		if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB)		{			size = sqlite3_value_bytes(argv[0]);			ogc = (const unsigned char*)sqlite3_value_blob(argv[0]);			middle_geo = _geo_from_wkb(ogc,size);		}		else if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_TEXT)		{			ogc = sqlite3_value_text(argv[0]);			middle_geo = _geo_from_wkt(ogc);		}		else if(argc == 4)		{			x1 = sqlite3_value_double(argv[0]);			y1 = sqlite3_value_double(argv[1]);			x2 = sqlite3_value_double(argv[2]);			y2 = sqlite3_value_double(argv[3]);			seq = GEOSCoordSeq_create(2,2);			GEOSCoordSeq_setX(seq,0,x1);			GEOSCoordSeq_setY(seq,0,y1);			GEOSCoordSeq_setX(seq,1,x2);			GEOSCoordSeq_setY(seq,1,y2);			middle_geo = GEOSGeom_createLineString(seq);		}		if(middle_geo != 0)		{			geometry = GEOSEnvelope(middle_geo);			if(geometry != 0)			{				ret_geo_buf = GEOSGeomToWKB_buf(geometry,&size);				sqlite3_result_blob(context,ret_geo_buf,size,SQLITE_TRANSIENT);				GEOSGeom_destroy(geometry);				GEOSFree(ret_geo_buf);			}			GEOSGeom_destroy(middle_geo);		}		finishGEOS();	}}

static void calculateDistance(sqlite3_context *ctx, int argc, sqlite3_value **argv) {    double distance = 0;    double lat1 = radians(sqlite3_value_double(argv[0]));    double lon1 = radians(sqlite3_value_double(argv[1]));    double lat2 = radians(sqlite3_value_double(argv[2]));    double lon2 = radians(sqlite3_value_double(argv[3]));    distance = acos( sin(lat1) * sin(lat2) + cos(lat1) * cos(lat2) * cos(lon2 - lon1) );    distance = (distance < 0 ? distance + M_PI : distance ) * EARTH_RADIUS;    sqlite3_result_double(ctx, distance);}

GEOPACKAGE_DECLARE voidfnct_gpkgMakePoint (sqlite3_context * context, int argc UNUSED,		    sqlite3_value ** argv){/* SQL function:/ gpkgMakePoint(x, y)// Creates a GeoPackage geometry POINT// returns nothing on success, raises exception on error*/    unsigned int len;    int int_value;    unsigned char *p_result = NULL;    double x;    double y;    GEOPACKAGE_UNUSED ();	/* LCOV_EXCL_LINE */    if (sqlite3_value_type (argv[0]) == SQLITE_FLOAT)      {	  x = sqlite3_value_double (argv[0]);      }    else if (sqlite3_value_type (argv[0]) == SQLITE_INTEGER)      {	  int_value = sqlite3_value_int (argv[0]);	  x = int_value;      }    else      {	  sqlite3_result_null (context);	  return;      }    if (sqlite3_value_type (argv[1]) == SQLITE_FLOAT)      {	  y = sqlite3_value_double (argv[1]);      }    else if (sqlite3_value_type (argv[1]) == SQLITE_INTEGER)      {	  int_value = sqlite3_value_int (argv[1]);	  y = int_value;      }    else      {	  sqlite3_result_null (context);	  return;      }    gpkgMakePoint (x, y, GEOPACKAGE_DEFAULT_UNDEFINED_SRID, &p_result, &len);    if (!p_result)      {	  sqlite3_result_null (context);      }    else      {	  sqlite3_result_blob (context, p_result, len, free);      }}

SEXPmakeRArgument(sqlite3_value *val){    SEXP ans = R_NilValue;    switch(sqlite3_value_type(val)) {       case SQLITE_INTEGER: {           int iVal = sqlite3_value_int(val);	   ans = ScalarInteger(iVal);	   break;       }       case SQLITE_FLOAT: {	   ans = ScalarReal(sqlite3_value_double(val));	   break;       }       case SQLITE_TEXT:	   ans = ScalarString(mkChar((char *) sqlite3_value_text(val)));	   break;       default:	   PROBLEM "Unhandled conversion of argument UDF from SQLite to R"	       WARN;	   break;    }    return(ans);}

extern void pg_stddev_step(sqlite3_context *context,                           int             argc,                           sqlite3_value **argv) {  CONTEXT_T *ctx;  int        typ;  double     val;  if ((typ = sqlite3_value_type(argv[0])) != SQLITE_NULL) {    if ((typ != SQLITE_INTEGER) && (typ != SQLITE_FLOAT)) {       ksu_err_msg(context, KSU_ERR_ARG_NOT_NUM, "stddev");       return;    }    ctx = (CONTEXT_T *)sqlite3_aggregate_context(context,                          sizeof(CONTEXT_T));    val = sqlite3_value_double(argv[0]);    if (ctx) {       if (ctx->n == 0) {          ctx->K = val;       }       ctx->sum += (val - ctx->K);       ctx->sum_sqr += (val - ctx->K)                     * (val - ctx->K);       (ctx->n)++;    }  }}

static voidconvert_sqlite_values_to_lua(lua_State *L, int nargs, sqlite3_value **values){    int i;    for(i = 0; i < nargs; i++) {        switch(sqlite3_value_type(values[i])) {            case SQLITE_INTEGER:                lua_pushinteger(L, sqlite3_value_int(values[i]));                break;            case SQLITE_FLOAT:                lua_pushnumber(L, sqlite3_value_double(values[i]));                break;            case SQLITE_NULL:                lua_pushnil(L);                break;            case SQLITE_BLOB:            case SQLITE_TEXT: {                size_t length;                length = sqlite3_value_bytes(values[i]);                lua_pushlstring(L, (const char *) sqlite3_value_text(values[i]), length);                break;            }        }    }}

bool Command::DoReadParam( void ){	Variable* var = mpVM->mVariables[ mObject ];		if( mpVM->mArgcRun <= mObject )	{		var->AssignValue( mpExpr->get_Value() );		return true;	}		sqlite3_value* vl = mpVM->mpArgv[ mObject ];	switch( sqlite3_value_type( vl ) )	{		case kDouble	: var->AssignValue( sqlite3_value_double( vl ) ); break;		case kInt		: var->AssignValue( sqlite3_value_int( vl ) ); break;				case kText		:		{			const char* str = (const char*) sqlite3_value_text( vl );			wstring wstr;			ConvertFromUTF8( str, strlen( str ), wstr );						var->AssignValue( wstr );		}		break;				default:			var->AssignValue( Value() );			break;	}		return true;}

SQLValue SQLiteStatement::getColumnValue(int col){    ASSERT(col >= 0);    if (!m_statement)        if (prepareAndStep() != SQLITE_ROW)            return SQLValue();    if (columnCount() <= col)        return SQLValue();    // SQLite is typed per value. optional column types are    // "(mostly) ignored"    sqlite3_value* value = sqlite3_column_value(m_statement, col);    switch (sqlite3_value_type(value)) {        case SQLITE_INTEGER:    // SQLValue and JS don't represent integers, so use FLOAT -case        case SQLITE_FLOAT:            return SQLValue(sqlite3_value_double(value));        case SQLITE_BLOB:       // SQLValue and JS don't represent blobs, so use TEXT -case        case SQLITE_TEXT: {            const UChar* string = reinterpret_cast<const UChar*>(sqlite3_value_text16(value));            unsigned length = WTF::lengthOfNullTerminatedString(string);            return SQLValue(StringImpl::create8BitIfPossible(string, length));        }        case SQLITE_NULL:            return SQLValue();        default:            break;    }    ASSERT_NOT_REACHED();    return SQLValue();}

void __SQLite3ExtMathSin(sqlite3_context *context, int argc, sqlite3_value **argv) {  if (argc == 1 && sqlite3_value_type(argv[0]) != SQLITE_NULL) {    sqlite3_result_double(context, sin(sqlite3_value_double(argv[0])));  } else {    sqlite3_result_null(context);  }}

SQLITE_EXTENSION_INIT1/*** returns */static void rank(sqlite3_context *pCtx, int nVal, sqlite3_value **apVal) {  int *aMatchinfo;  int nCol;  int nPhrase;  int iPhrase;  double score = 0.0;  aMatchinfo = (int *)sqlite3_value_blob(apVal[0]);  nPhrase = aMatchinfo[0];  nCol = aMatchinfo[1];  // do a simple count on string match  for(iPhrase=0; iPhrase<nPhrase; iPhrase++) {    int iCol;    int *aPhraseinfo = &aMatchinfo[2 + iPhrase*nCol*3];    for(iCol=0; iCol<nCol; iCol++){      int nHitCount = aPhraseinfo[3*iCol];      int nGlobalHitCount = aPhraseinfo[3*iCol+1];      double weight = sqlite3_value_double(apVal[iCol+1]);      if( nHitCount>0 ){        score += ((double)nHitCount / (double)nGlobalHitCount) * weight;      }    }  }  sqlite3_result_double(pCtx, score);  return;}

void geo_simplify(sqlite3_context *context,int argc,sqlite3_value **argv){	if(argc == 2 && sqlite3_value_type(argv[0]) == SQLITE_BLOB)	{ 		GEOSGeometry* geometry;		GEOSGeometry* simplify_geo;		unsigned char* wkb;		size_t size;		const void* data = sqlite3_value_blob(argv[0]);		size_t data_size = sqlite3_value_bytes(argv[0]);		double tolerance = sqlite3_value_double(argv[1]);		_init_geos();		geometry = _geo_from_wkb((const unsigned char*)data,data_size);		if(geometry != 0)		{			simplify_geo = GEOSSimplify(geometry,tolerance);			if(simplify_geo != 0)			{				wkb = GEOSGeomToWKB_buf(simplify_geo,&size);				sqlite3_result_blob(context,wkb,size,SQLITE_TRANSIENT);				GEOSGeom_destroy(simplify_geo);				GEOSFree(wkb);			}		}		GEOSGeom_destroy(geometry);		finishGEOS();	}}

/*** Process time function arguments.  argv[0] is a date-time stamp.** argv[1] and following are modifiers.  Parse them all and write** the resulting time into the DateTime structure p.  Return 0** on success and 1 if there are any errors.**** If there are zero parameters (if even argv[0] is undefined)** then assume a default value of "now" for argv[0].*/static int isDate(  sqlite3_context *context,   int argc,   sqlite3_value **argv,   DateTime *p){  int i;  const unsigned char *z;  int eType;  memset(p, 0, sizeof(*p));  if( argc==0 ){    return setDateTimeToCurrent(context, p);  }  if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT                   || eType==SQLITE_INTEGER ){    p->iJD = (sqlite3_int64)(sqlite3_value_double(argv[0])*86400000.0 + 0.5);    p->validJD = 1;  }else{    z = sqlite3_value_text(argv[0]);    if( !z || parseDateOrTime(context, (char*)z, p) ){      return 1;    }  }  for(i=1; i<argc; i++){    z = sqlite3_value_text(argv[i]);    if( z==0 || parseModifier(context, (char*)z, p) ) return 1;  }  return 0;}

/*** Implementation of the abs() function*/static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){  assert( argc==1 );  switch( sqlite3_value_type(argv[0]) ){    case SQLITE_INTEGER: {      i64 iVal = sqlite3_value_int64(argv[0]);      if( iVal<0 ){        if( (iVal<<1)==0 ){          sqlite3_result_error(context, "integer overflow", -1);          return;        }        iVal = -iVal;      }       sqlite3_result_int64(context, iVal);      break;    }    case SQLITE_NULL: {      sqlite3_result_null(context);      break;    }    default: {      double rVal = sqlite3_value_double(argv[0]);      if( rVal<0 ) rVal = -rVal;      sqlite3_result_double(context, rVal);      break;    }  }}

static void sqlite_callback_args(int argc, sqlite3_value **argv){    int i;    for (i = 0; i < argc; i++) {        sqlite3_value *sv = argv[i];        Value *vp = fg->stk_top;        switch (sqlite3_value_type(sv)) {        case SQLITE_INTEGER:            *vp = fs->int64_Value(sqlite3_value_int64(sv));            break;        case SQLITE_FLOAT:            *vp = fs->float_Value(fs->cls_float, sqlite3_value_double(sv));            break;        case SQLITE_TEXT: {            const char *p = (const char*)sqlite3_value_text(sv);            int len = sqlite3_value_bytes(sv);            *vp = fs->cstr_Value(NULL, p, len);            break;        }        case SQLITE_BLOB: {            const char *p = (const char*)sqlite3_value_blob(sv);            int len = sqlite3_value_bytes(sv);            *vp = fs->cstr_Value(fs->cls_bytes, p, len);            break;        }        default:            *vp = VALUE_NULL;            break;        }        fg->stk_top++;    }}

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]);  /* If Y==0 and X will fit in a 64-bit int,  ** handle the rounding directly,  ** otherwise use printf.  */  if( n==0 && r>=0 && r<LARGEST_INT64-1 ){    r = (double)((sqlite_int64)(r+0.5));  }else if( n==0 && r<0 && (-r)<LARGEST_INT64-1 ){    r = -(double)((sqlite_int64)((-r)+0.5));  }else{    zBuf = sqlite3_mprintf("%.*f",n,r);    if( zBuf==0 ){      sqlite3_result_error_nomem(context);      return;    }    sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);    sqlite3_free(zBuf);  }  sqlite3_result_double(context, r);}

/*** The cube() SQL function returns the cube of its input value.*/static void cubeFunc(  sqlite3_context *context,  int argc,  sqlite3_value **argv){  double r = sqlite3_value_double(argv[0]);  sqlite3_result_double(context, r*r*r);}

/*** Routines used to compute the sum */static void SStep(sqlite3_context *context, int argc, sqlite3_value **argv){  SCtx *p=NULL;  int i;  std::string d;  if( argc<1 ) return;  p = (SCtx *) sqlite3_aggregate_context(context, sizeof(*p));  if( p->cnt == 0)    {      if ( sscnt  >= MAXSSC )	{ fprintf(stderr,"MAXSSC needs to increase/n");	  exit(1);	}      p->sscnt=sscnt;      sscnt++;      ss[p->sscnt].str("");      ss[p->sscnt] << "(";     d="";    } else {       d=",";           }        p->sum += sqlite3_value_double(argv[0]);    p->cnt++;    ss[p->sscnt] << d <<  p->sum ;/* *      If the simple function is not used this *      comes into play. */    if (p->cnt == 1)      {	for(i=1; i< argc; ++i) {          p->cnt++;	  p->sum+=sqlite3_value_double(argv[i]);          ss[p->sscnt] <<  "," << p->sum ;	  }      }}

/*** Implementation of bm25() function.*/static void fts5Bm25Function(  const Fts5ExtensionApi *pApi,   /* API offered by current FTS version */  Fts5Context *pFts,              /* First arg to pass to pApi functions */  sqlite3_context *pCtx,          /* Context for returning result/error */  int nVal,                       /* Number of values in apVal[] array */  sqlite3_value **apVal           /* Array of trailing arguments */){  const double k1 = 1.2;          /* Constant "k1" from BM25 formula */  const double b = 0.75;          /* Constant "b" from BM25 formula */  int rc = SQLITE_OK;             /* Error code */  double score = 0.0;             /* SQL function return value */  Fts5Bm25Data *pData;            /* Values allocated/calculated once only */  int i;                          /* Iterator variable */  int nInst = 0;                  /* Value returned by xInstCount() */  double D = 0.0;                 /* Total number of tokens in row */  double *aFreq = 0;              /* Array of phrase freq. for current row */  /* Calculate the phrase frequency (symbol "f(qi,D)" in the documentation)  ** for each phrase in the query for the current row. */  rc = fts5Bm25GetData(pApi, pFts, &pData);  if( rc==SQLITE_OK ){    aFreq = pData->aFreq;    memset(aFreq, 0, sizeof(double) * pData->nPhrase);    rc = pApi->xInstCount(pFts, &nInst);  }  for(i=0; rc==SQLITE_OK && i<nInst; i++){    int ip; int ic; int io;    rc = pApi->xInst(pFts, i, &ip, &ic, &io);    if( rc==SQLITE_OK ){      double w = (nVal > ic) ? sqlite3_value_double(apVal[ic]) : 1.0;      aFreq[ip] += w;    }  }  /* Figure out the total size of the current row in tokens. */  if( rc==SQLITE_OK ){    int nTok;    rc = pApi->xColumnSize(pFts, -1, &nTok);    D = (double)nTok;  }  /* Determine the BM25 score for the current row. */  for(i=0; rc==SQLITE_OK && i<pData->nPhrase; i++){    score += pData->aIDF[i] * (      ( aFreq[i] * (k1 + 1.0) ) /       ( aFreq[i] + k1 * (1 - b + b * D / pData->avgdl) )    );  }    /* If no error has occurred, return the calculated score. Otherwise,  ** throw an SQL exception.  */  if( rc==SQLITE_OK ){    sqlite3_result_double(pCtx, -1.0 * score);  }else{    sqlite3_result_error_code(pCtx, rc);  }}

/*** Routines used to compute the sum or average.*/static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){  SumCtx *p;  if( argc<1 ) return;  p = sqlite3_aggregate_context(context, sizeof(*p));  if( p && SQLITE_NULL!=sqlite3_value_type(argv[0]) ){    p->sum += sqlite3_value_double(argv[0]);    p->cnt++;  }}

SQLITE_EXTENSION_INIT1static void halfFunc(  sqlite3_context *context,  int argc,  sqlite3_value **argv){  sqlite3_result_double(context, 0.5*sqlite3_value_double(argv[0]));}

/*** Output an sqlite3_value object's value as an SQL literal.*/static void vtablogQuote(sqlite3_value *p){  char z[50];  switch( sqlite3_value_type(p) ){    case SQLITE_NULL: {      printf("NULL");      break;    }    case SQLITE_INTEGER: {      sqlite3_snprintf(50,z,"%lld", sqlite3_value_int64(p));      printf("%s", z);      break;    }    case SQLITE_FLOAT: {      sqlite3_snprintf(50,z,"%!.20g", sqlite3_value_double(p));      printf("%s", z);      break;    }    case SQLITE_BLOB: {      int n = sqlite3_value_bytes(p);      const unsigned char *z = (const unsigned char*)sqlite3_value_blob(p);      int i;      printf("x'");      for(i=0; i<n; i++) printf("%02x", z[i]);      printf("'");      break;    }    case SQLITE_TEXT: {      const char *z = (const char*)sqlite3_value_text(p);      int i;      char c;      for(i=0; (c = z[i])!=0 && c!='/''; i++){}      if( c==0 ){        printf("'%s'",z);      }else{        printf("'");        while( *z ){          for(i=0; (c = z[i])!=0 && c!='/''; i++){}          if( c=='/'' ) i++;          if( i ){            printf("%.*s", i, z);            z += i;          }          if( c=='/'' ){            printf("'");            continue;          }          if( c==0 ){            break;          }          z++;        }        printf("'");      }      break;    }  }}

extern void     ora_sinh(sqlite3_context * context,                         int               argc,                         sqlite3_value  ** argv) {        double          number;        if (ksu_prm_ok(context, argc, argv, "sinh", KSU_PRM_NUMERIC)) {           number = sqlite3_value_double(argv[0]);           sqlite3_result_double(context, sinh(number));        }}

/* * Returns the tangent of the first argument. */extern void     ora_tan(sqlite3_context * context,                        int                argc,                        sqlite3_value   ** argv) {        double          val;        if (ksu_prm_ok(context, argc, argv, "tan", KSU_PRM_NUMERIC)) {           val = sqlite3_value_double(argv[0]);           sqlite3_result_double(context, tan(val));        }}

/* * Compute the distance between two points on earth using the Haversine formula * cf: http://en.wikipedia.org/wiki/Haversine_formula */static void haversine(sqlite3_context *context, int argc, sqlite3_value **argv){    assert(argc == 4);    double  lat1 = deg2rad(sqlite3_value_double(argv[0]));    double long1 = deg2rad(sqlite3_value_double(argv[1]));    double  lat2 = deg2rad(sqlite3_value_double(argv[2]));    double long2 = deg2rad(sqlite3_value_double(argv[3]));        double  dlat = fabs(lat1 - lat2);    double dlong = fabs(long1 - long2);        double angle = 2 * asin(        sqrt(pow(sin(dlat/2), 2) +              cos(lat1) * cos(lat2) * pow(sin(dlong/2), 2)));    double res = angle * (equatorial_radius + polar_radius)/2;    return sqlite3_result_double(context, res);}

extern void  pg_log(sqlite3_context * context,                    int               argc,                    sqlite3_value  ** argv) {        double  val;        double  base;        _ksu_check_arg_cnt(argc, 1, 2, "log");        if (argc == 2) {          base = sqlite3_value_double(argv[0]);          if ((base <= 0) || (base == 1)) {            ksu_err_msg(context,  KSU_ERR_INV_ARG_VAL_RANGE, "log");            return;          }          val = sqlite3_value_double(argv[1]);        } else {          base = 10;          val = sqlite3_value_double(argv[0]);        }        sqlite3_result_double(context, log(val) / log(base));}

static void powerFunc(sqlite3_context* context,                      int argc,                      sqlite3_value** argv) {  assert(argc == 2);  if (sqlite3_value_type(argv[0]) == SQLITE_NULL ||      sqlite3_value_type(argv[1]) == SQLITE_NULL) {    sqlite3_result_null(context);  } else {    double r1 = sqlite3_value_double(argv[0]);    double r2 = sqlite3_value_double(argv[1]);    errno = 0;    double val = pow(r1, r2);    if (errno == 0) {      sqlite3_result_double(context, val);    } else {      sqlite3_result_error(context, platformStrerr(errno).c_str(), errno);    }  }}

static double getRealResult(const RtlFieldInfo *field, sqlite3_value *val){    assertex(val);    if (isNull(val))    {        NullFieldProcessor p(field);        return p.doubleResult;    }    if (sqlite3_value_type(val) != SQLITE_FLOAT)        typeError("real", field);    return sqlite3_value_double(val);}