/*
** 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();
}
}
