/* ** 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); } }
static void 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); }
/* ** 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; } } }
/* 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 void xmms_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]); } }
/* ** Routines used to compute the sum or average. */ static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ SumCtx *p; int type; assert( argc==1 ); p = sqlite3_aggregate_context(context, sizeof(*p)); type = sqlite3_value_type(argv[0]); if( p && type!=SQLITE_NULL ){ p->sum += sqlite3_value_double(argv[0]); p->cnt++; if( type==SQLITE_FLOAT ){ p->seenFloat = 1; } } }
static void 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); }
static void 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); }
static void 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_INIT1 static 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 ö-b6>96 ú-ba>9a ü-bc>9c */ result[pos] = input[pos] & 0xdf; pos++; break; case 0xc5: /* ő-91>90 ű-b1>b0 */ result[pos] = input[pos] & 0xfe; pos++; break; } } sqlite3_result_text(ctx, (char *)result, length, sqlite3_free); return; }
static void SFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ std::stringstream s; std::string d; double sum=0; char *buf=NULL; int i; s.str(""); s << "("; d=""; for(i=0; i < argc; i++) { switch( sqlite3_value_type(argv[i]) ){ case SQLITE_INTEGER: { sum+=(double) sqlite3_value_int64(argv[i]); s << d << sum; d=","; break; } case SQLITE_NULL: { s << d << "()"; d=","; break; } default: { sum+=sqlite3_value_int64(argv[i]); s << d << sum; d=","; break; } } } s << ")"; buf = (char *) malloc (sizeof(char)*(s.str().size()+2)); if (buf == NULL) fprintf(stderr,"malloc error in SNFunc, buf\n"); snprintf(buf,s.str().size()+1,"%s",s.str().c_str()); sqlite3_result_text(context,buf,s.str().size()+1,free ); }
void geo_subgeos(sqlite3_context *context,int argc,sqlite3_value **argv) { if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB) { GEOSGeometry* geometry; const void* data = sqlite3_value_blob(argv[0]); size_t data_size = sqlite3_value_bytes(argv[0]); _init_geos(); geometry = _geo_from_wkb((const unsigned char*)data,data_size); if(geometry != 0) { int sub_geos = GEOSGetNumGeometries(geometry); sqlite3_result_int(context,sub_geos); } GEOSGeom_destroy(geometry); finishGEOS(); } }
void geo_valid(sqlite3_context *context,int argc,sqlite3_value **argv) { if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB) { GEOSGeometry* geometry; const void* data = sqlite3_value_blob(argv[0]); size_t data_size = sqlite3_value_bytes(argv[0]); _init_geos(); geometry = _geo_from_wkb((const unsigned char*)data,data_size); if(geometry != 0) { char empty = (GEOSisValid(geometry) == 1) ? 1 : 0; sqlite3_result_int(context,empty); } GEOSGeom_destroy(geometry); finishGEOS(); } }
extern void my_ceil(sqlite3_context * context, int argc, sqlite3_value ** argv) { double val; int typ; typ = sqlite3_value_type(argv[0]); if (typ == SQLITE_NULL) { sqlite3_result_null(context); } else { if ((typ == SQLITE_INTEGER) || (typ == SQLITE_FLOAT)) { val = sqlite3_value_double(argv[0]); sqlite3_result_int64(context, (long)ceil(val)); } else { //Wrong input sqlite3_result_int(context, 0); } } }
void geo_maxy(sqlite3_context *context,int argc,sqlite3_value **argv) { if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB) { GEOSGeometry* geometry; Rect rect; const void* data = sqlite3_value_blob(argv[0]); size_t data_size = sqlite3_value_bytes(argv[0]); _init_geos(); geometry = _geo_from_wkb((const unsigned char*)data,data_size); if(geometry != 0) { _get_envelope(geometry,&rect); sqlite3_result_double(context,rect.maxY); } GEOSGeom_destroy(geometry); finishGEOS(); } }
void geo_length(sqlite3_context *context,int argc,sqlite3_value **argv) { if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB) { GEOSGeometry* geometry; const void* data = sqlite3_value_blob(argv[0]); size_t data_size = sqlite3_value_bytes(argv[0]); _init_geos(); geometry = _geo_from_wkb((const unsigned char*)data,data_size); if(geometry != 0) { double length = 0; GEOSLength(geometry,&length); sqlite3_result_double(context,length); } GEOSGeom_destroy(geometry); finishGEOS(); } }