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 void
fnct_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);
}
}
SEXP
makeRArgument(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 void
convert_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_INIT1
static 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);
}