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