static void renameParentFunc(
sqlite3_context *context,
int NotUsed,
sqlite3_value **argv
){
sqlite3 *db = sqlite3_context_db_handle(context);
char *zOutput = 0;
char *zResult;
unsigned char const *zInput = sqlite3_value_text(argv[0]);
unsigned char const *zOld = sqlite3_value_text(argv[1]);
unsigned char const *zNew = sqlite3_value_text(argv[2]);
unsigned const char *z; /* Pointer to token */
int n; /* Length of token z */
int token; /* Type of token */
UNUSED_PARAMETER(NotUsed);
for(z=zInput; *z; z=z+n){
n = sqlite3GetToken(z, &token);
if( token==TK_REFERENCES ){
char *zParent;
do {
z += n;
n = sqlite3GetToken(z, &token);
}while( token==TK_SPACE );
zParent = sqlite3DbStrNDup(db, (const char *)z, n);
if( zParent==0 ) break;
sqlite3Dequote(zParent);
if( 0==sqlite3StrICmp((const char *)zOld, zParent) ){
char *zOut = sqlite3MPrintf(db, "%s%.*s\"%w\"",
(zOutput?zOutput:""), z-zInput, zInput, (const char *)zNew
);
sqlite3DbFree(db, zOutput);
zOutput = zOut;
zInput = &z[n];
}
sqlite3DbFree(db, zParent);
}
}
zResult = sqlite3MPrintf(db, "%s%s", (zOutput?zOutput:""), zInput),
sqlite3_result_text(context, zResult, -1, SQLITE_DYNAMIC);
sqlite3DbFree(db, zOutput);
}
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 ){
static void
function_offsets (sqlite3_context *context,
int argc,
sqlite3_value *argv[])
{
gchar *offsets, **names;
gint offset_values[4];
GString *result = NULL;
gint i = 0;
if (argc != 2) {
sqlite3_result_error(context,
"wrong number of arguments to function tracker_offsets()",
-1);
return;
}
offsets = sqlite3_value_text (argv[0]);
names = (unsigned int *) sqlite3_value_blob (argv[1]);
while (offsets && *offsets) {
offset_values[i] = g_strtod (offsets, &offsets);
/* All 4 values from the quartet have been gathered */
if (i == 3) {
if (!result) {
result = g_string_new ("");
} else {
g_string_append_c (result, ',');
}
g_string_append_printf (result,
"%s,%d",
names[offset_values[0]],
offset_values[2]);
}
i = (i + 1) % 4;
}
sqlite3_result_text (context,
(result) ? g_string_free (result, FALSE) : NULL,
-1, g_free);
}
extern void pg_string_agg_final(sqlite3_context *context) {
STRING_AGG_CONTEXT_T *ctx;
ctx = (STRING_AGG_CONTEXT_T *)sqlite3_aggregate_context(context,0);
if (ctx) {
if (ctx->sz == 0) {
sqlite3_result_null(context);
} else {
// SQLite3 will free what we have allocated
sqlite3_result_text(context, (char *)ctx->aggr, ctx->len, sqlite3_free);
ctx->aggr = (char *)NULL;
ctx->sz = 0;
ctx->len = 0;
}
} else {
sqlite3_result_null(context);
}
}
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;
}
/*
** This function is used by SQL generated to implement the
** ALTER TABLE command. The first argument is the text of a CREATE TABLE or
** CREATE INDEX command. The second is a table name. The table name in
** the CREATE TABLE or CREATE INDEX statement is replaced with the third
** argument and the result returned. Examples:
**
** sqlite_rename_table('CREATE TABLE abc(a, b, c)', 'def')
** -> 'CREATE TABLE def(a, b, c)'
**
** sqlite_rename_table('CREATE INDEX i ON abc(a)', 'def')
** -> 'CREATE INDEX i ON def(a, b, c)'
*/
static void renameTableFunc(
sqlite3_context *context,
int argc,
sqlite3_value **argv
){
unsigned char const *zSql = sqlite3_value_text(argv[0]);
unsigned char const *zTableName = sqlite3_value_text(argv[1]);
int token;
Token tname;
unsigned char const *zCsr = zSql;
int len = 0;
char *zRet;
/* The principle used to locate the table name in the CREATE TABLE
** statement is that the table name is the first token that is immediatedly
** followed by a left parenthesis - TK_LP - or "USING" TK_USING.
*/
if( zSql ){
do {
if( !*zCsr ){
/* Ran out of input before finding an opening bracket. Return NULL. */
return;
}
/* Store the token that zCsr points to in tname. */
tname.z = zCsr;
tname.n = len;
/* Advance zCsr to the next token. Store that token type in 'token',
** and it's length in 'len' (to be used next iteration of this loop).
*/
do {
zCsr += len;
len = sqlite3GetToken(zCsr, &token);
} while( token==TK_SPACE );
assert( len>0 );
} while( token!=TK_LP && token!=TK_USING );
zRet = sqlite3MPrintf("%.*s%Q%s", tname.z - zSql, zSql,
zTableName, tname.z+tname.n);
sqlite3_result_text(context, zRet, -1, sqlite3FreeX);
}
}
/*
** hex_to_utf8(HEX)
**
** Convert the input string from HEX into binary. Then return the
** result using sqlite3_result_text16le().
*/
static void testHexToUtf8(
sqlite3_context *pCtx,
int nArg,
sqlite3_value **argv
){
int n;
const char *zIn;
char *zOut;
assert( nArg==1 );
n = sqlite3_value_bytes(argv[0]);
zIn = (const char*)sqlite3_value_text(argv[0]);
zOut = sqlite3_malloc( n/2 );
if( zOut==0 ){
sqlite3_result_error_nomem(pCtx);
}else{
testHexToBin(zIn, zOut);
sqlite3_result_text(pCtx, zOut, n/2, sqlite3_free);
}
}
/*
* Doesn't exactly behaves as the PostgreSQL version as a \
* leaves sqlite completely cold. Serves, however, the
* same purpose, which is making data extracted from the
* database usable in a statement.
*/
extern void pg_quote_literal(sqlite3_context * context,
int argc,
sqlite3_value ** argv) {
int len;
char *str;
char *result = (char *)NULL;
int resultsz;
int i;
int j;
_ksu_null_if_null_param(argc, argv);
len = sqlite3_value_bytes(argv[0]);
str = (char *)sqlite3_value_blob(argv[0]);
if ((result = (char *)sqlite3_malloc(len + SAFETY_MARGIN + 1))
== (char *)NULL) {
sqlite3_result_error_nomem(context);
return;
}
resultsz = len + SAFETY_MARGIN;
*result = '\'';
j = 1;
for (i = 0; i < len; i++) {
switch (str[i]) {
case '\'': // Escape quote
result[j++] = '\'';
break;
default :
break;
}
result[j++] = str[i];
if (j >= resultsz - 2) { // Time to realloc
if ((result = (char *)sqlite3_realloc(result,
resultsz + SAFETY_MARGIN + 1))
== (char *)NULL) {
sqlite3_result_error_nomem(context);
return;
}
resultsz += SAFETY_MARGIN;
}
}
result[j++] = '\'';
sqlite3_result_text(context, result, j, sqlite3_free);
}
/**
* Obtains the first UNICODE letter from the supplied string, normalizes and returns it.
*/
static void get_phonebook_index(
sqlite3_context * context, int argc, sqlite3_value ** argv)
{
if (argc != 2) {
sqlite3_result_null(context);
return;
}
char const * src = (char const *)sqlite3_value_text(argv[0]);
char const * locale = (char const *)sqlite3_value_text(argv[1]);
if (src == NULL || src[0] == 0 || locale == NULL) {
sqlite3_result_null(context);
return;
}
UCharIterator iter;
uiter_setUTF8(&iter, src, -1);
UBool isError = FALSE;
UChar index[SMALL_BUFFER_SIZE];
uint32_t len = android::GetPhonebookIndex(&iter, locale, index, sizeof(index), &isError);
if (isError) {
sqlite3_result_null(context);
return;
}
uint32_t outlen = 0;
uint8_t out[SMALL_BUFFER_SIZE];
for (uint32_t i = 0; i < len; i++) {
U8_APPEND(out, outlen, sizeof(out), index[i], isError);
if (isError) {
sqlite3_result_null(context);
return;
}
}
if (outlen == 0) {
sqlite3_result_null(context);
return;
}
sqlite3_result_text(context, (const char*)out, outlen, SQLITE_TRANSIENT);
}
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 );
}
static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
char *z1;
const char *z2;
int i, n;
UNUSED_PARAMETER(argc);
z2 = (char*)sqlite3_value_text(argv[0]);
n = sqlite3_value_bytes(argv[0]);
/* Verify that the call to _bytes() does not invalidate the _text() pointer */
assert( z2==(char*)sqlite3_value_text(argv[0]) );
if( z2 ){
z1 = contextMalloc(context, ((i64)n)+1);
if( z1 ){
for(i=0; i<n; i++){
z1[i] = sqlite3Tolower(z2[i]);
}
sqlite3_result_text(context, z1, n, sqlite3_free);
}
}
}
static void ST_GeometryType(sqlite3_context *context, int nbArgs, sqlite3_value **args) {
spatialdb_t *spatialdb;
FUNCTION_WKB_ARG(wkb);
FUNCTION_START_STATIC(context, 256);
spatialdb = (spatialdb_t *)sqlite3_user_data(context);
FUNCTION_GET_WKB_ARG_UNSAFE(context, spatialdb, wkb, 0);
const char *type_name;
if (geom_type_name(wkb.geom_type, &type_name) == SQLITE_OK) {
sqlite3_result_text(context, type_name, -1, SQLITE_STATIC);
} else {
error_append(FUNCTION_ERROR, "Unknown geometry type: %d", wkb.geom_type);
}
FUNCTION_END(context);
FUNCTION_FREE_WKB_ARG(wkb);
}
static
void OGRSQLITE_hstore_get_value(sqlite3_context* pContext,
int argc, sqlite3_value** argv)
{
if( sqlite3_value_type (argv[0]) != SQLITE_TEXT ||
sqlite3_value_type (argv[1]) != SQLITE_TEXT )
{
sqlite3_result_null (pContext);
return;
}
const char* pszHStore = (const char*)sqlite3_value_text(argv[0]);
const char* pszSearchedKey = (const char*)sqlite3_value_text(argv[1]);
char* pszValue = OGRHStoreGetValue(pszHStore, pszSearchedKey);
if( pszValue != NULL )
sqlite3_result_text( pContext, pszValue, -1, CPLFree );
else
sqlite3_result_null( pContext );
}
static void phone_number_stripped_reversed(sqlite3_context * context, int argc,
sqlite3_value ** argv)
{
if (argc != 1) {
sqlite3_result_int(context, 0);
return;
}
char const * number = (char const *)sqlite3_value_text(argv[0]);
if (number == NULL) {
sqlite3_result_null(context);
return;
}
char out[PHONE_NUMBER_BUFFER_SIZE];
int outlen = 0;
android::phone_number_stripped_reversed_inter(number, out, PHONE_NUMBER_BUFFER_SIZE, &outlen);
sqlite3_result_text(context, (const char*)out, outlen, SQLITE_TRANSIENT);
}
/*
** Implementation of highlight() function.
*/
static void fts5HighlightFunction(
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 */
){
HighlightContext ctx;
int rc;
int iCol;
if( nVal!=3 ){
const char *zErr = "wrong number of arguments to function highlight()";
sqlite3_result_error(pCtx, zErr, -1);
return;
}
iCol = sqlite3_value_int(apVal[0]);
memset(&ctx, 0, sizeof(HighlightContext));
ctx.zOpen = (const char*)sqlite3_value_text(apVal[1]);
ctx.zClose = (const char*)sqlite3_value_text(apVal[2]);
rc = pApi->xColumnText(pFts, iCol, &ctx.zIn, &ctx.nIn);
if( ctx.zIn ){
if( rc==SQLITE_OK ){
rc = fts5CInstIterInit(pApi, pFts, iCol, &ctx.iter);
}
if( rc==SQLITE_OK ){
rc = pApi->xTokenize(pFts, ctx.zIn, ctx.nIn, (void*)&ctx,fts5HighlightCb);
}
fts5HighlightAppend(&rc, &ctx, &ctx.zIn[ctx.iOff], ctx.nIn - ctx.iOff);
if( rc==SQLITE_OK ){
sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
}
sqlite3_free(ctx.zOut);
}
if( rc!=SQLITE_OK ){
sqlite3_result_error_code(pCtx, rc);
}
}
static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
char *z1;
const char *z2;
int i, n;
if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
z2 = (char*)sqlite3_value_text(argv[0]);
n = sqlite3_value_bytes(argv[0]);
/* Verify that the call to _bytes() does not invalidate the _text() pointer */
assert( z2==(char*)sqlite3_value_text(argv[0]) );
if( z2 ){
z1 = sqlite3_malloc(n+1);
if( z1 ){
memcpy(z1, z2, n+1);
for(i=0; z1[i]; i++){
z1[i] = tolower(z1[i]);
}
sqlite3_result_text(context, z1, -1, sqlite3_free);
}
}
}
static void listFinalize(sqlite3_context *context){
Ltx *p=NULL;
char *buf=NULL;
p = (Ltx *) sqlite3_aggregate_context(context, sizeof(*p));
ssL[p->sscnt] << ")";
buf = (char *) malloc (sizeof(char)*(ssL[p->sscnt].str().size()+2));
if (buf == NULL)
fprintf(stderr,"malloc error in listFinalize, buf\n");
snprintf(buf,ssL[p->sscnt].str().size()+1,"%s",ssL[p->sscnt].str().c_str());
sqlite3_result_text(context,buf,ssL[p->sscnt].str().size()+2,free );
ssL[p->sscnt].clear();
sscntL--;
}
static void FFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
assert( argc==1 );
char *buf=NULL;
std::stringstream s;
std::string ts;
extract e;
e.setdelims(", ");
s.str("");
s << sqlite3_value_text(argv[0]);
e.strip(s.str());
s.str(e.F());
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 );
}
/*
** Return values of columns for the row at which the vtablog_cursor
** is currently pointing.
*/
static int vtablogColumn(
sqlite3_vtab_cursor *cur, /* The cursor */
sqlite3_context *ctx, /* First argument to sqlite3_result_...() */
int i /* Which column to return */
){
vtablog_cursor *pCur = (vtablog_cursor*)cur;
vtablog_vtab *pTab = (vtablog_vtab*)cur->pVtab;
char zVal[50];
if( i<26 ){
sqlite3_snprintf(sizeof(zVal),zVal,"%c%d",
"abcdefghijklmnopqrstuvwyz"[i], pCur->iRowid);
}else{
sqlite3_snprintf(sizeof(zVal),zVal,"{%d}%d", i, pCur->iRowid);
}
printf("vtablogColumn(tab=%d, cursor=%d, i=%d): [%s]\n",
pTab->iInst, pCur->iCursor, i, zVal);
sqlite3_result_text(ctx, zVal, -1, SQLITE_TRANSIENT);
return SQLITE_OK;
}
void qquncompress(sqlite3_context* context, int argc, sqlite3_value** argv)
{
#ifdef ZIP
int len = sqlite3_value_bytes(argv[0]);
unsigned char* msg = sqlite3_malloc(sizeof(unsigned char) * len);
memcpy(msg, sqlite3_value_blob(argv[0]), len);
unsigned long destlen;
unsigned char* msg2 = qq_uncompress(msg, &destlen, len);
sqlite3_free(msg);
sqlite3_result_blob(context, msg2, destlen, sqlite3_free);
#else
const char* msg = sqlite3_value_text(argv[0]);
char* msg2 = base64_decode((char*) msg);
sqlite3_result_text(context, msg2, strlen(msg2), sqlite3_free);
#endif
}
/*
* unzip --
* User defined Sqlite function to uncompress the FTS table.
*/
static void
unzip(sqlite3_context *pctx, int nval, sqlite3_value **apval)
{
unsigned int rc;
unsigned char *outbuf;
z_stream stream;
assert(nval == 1);
stream.next_in = __UNCONST(sqlite3_value_blob(apval[0]));
stream.avail_in = sqlite3_value_bytes(apval[0]);
stream.avail_out = stream.avail_in * 2 + 100;
stream.next_out = outbuf = malloc(stream.avail_out);
assert(outbuf);
stream.zalloc = NULL;
stream.zfree = NULL;
inflateInit(&stream);
if (inflateInit(&stream) != Z_OK) {
free(outbuf);
return;
}
while ((rc = inflate(&stream, Z_SYNC_FLUSH)) != Z_STREAM_END) {
if (rc != Z_OK ||
(stream.avail_out != 0 && stream.avail_in == 0)) {
free(outbuf);
return;
}
outbuf = realloc(outbuf, stream.total_out * 2);
assert(outbuf);
stream.next_out = outbuf + stream.total_out;
stream.avail_out = stream.total_out;
}
if (inflateEnd(&stream) != Z_OK) {
free(outbuf);
return;
}
outbuf = realloc(outbuf, stream.total_out);
assert(outbuf);
sqlite3_result_text(pctx, outbuf, stream.total_out, free);
}
/*
** The hex() function. Interpret the argument as a blob. Return
** a hexadecimal rendering as text.
*/
static void hexFunc(
sqlite3_context *context,
int argc,
sqlite3_value **argv
) {
int i, n;
const unsigned char *pBlob;
char *zHex, *z;
assert( argc==1 );
pBlob = sqlite3_value_blob(argv[0]);
n = sqlite3_value_bytes(argv[0]);
z = zHex = sqlite3_malloc(n*2 + 1);
if( zHex==0 ) return;
for(i=0; i<n; i++, pBlob++) {
unsigned char c = *pBlob;
*(z++) = hexdigits[(c>>4)&0xf];
*(z++) = hexdigits[c&0xf];
}
*z = 0;
sqlite3_result_text(context, zHex, n*2, sqlite3_free);
}
void gbk(sqlite3_context *context,int argc,sqlite3_value **argv)
{
if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_TEXT)
{
const unsigned char* text = sqlite3_value_text(argv[0]);
size_t textLen = sqlite3_value_bytes(argv[0]);
size_t outLen = textLen * 4;
char* out = (char*)sqlite3_malloc(outLen);
char* pout = out;
iconv_t handle = iconv_open("gbk","utf-8");
memset(out,0,outLen);
iconv(handle,(const char**)&text,&textLen,&pout,&outLen);
iconv_close(handle);
sqlite3_result_text(context,out,-1,SQLITE_TRANSIENT);
sqlite3_free(out);
}
}
static void checkfreelist_function(
sqlite3_context *pCtx,
int nArg,
sqlite3_value **apArg
){
const char *zDb;
int rc;
char *zOut = 0;
sqlite3 *db = sqlite3_context_db_handle(pCtx);
assert( nArg==1 );
zDb = (const char*)sqlite3_value_text(apArg[0]);
rc = checkFreelist(db, zDb, &zOut);
if( rc==SQLITE_OK ){
sqlite3_result_text(pCtx, zOut?zOut:"ok", -1, SQLITE_TRANSIENT);
}else{
sqlite3_result_error_code(pCtx, rc);
}
sqlite3_free(zOut);
}
/*
** Implementation of the substr() function
*/
static void substrFunc(
sqlite3_context *context,
int argc,
sqlite3_value **argv
){
const unsigned char *z;
const unsigned char *z2;
int i;
int p1, p2, len;
assert( argc==3 );
z = sqlite3_value_text(argv[0]);
if( z==0 ) return;
p1 = sqlite3_value_int(argv[1]);
p2 = sqlite3_value_int(argv[2]);
for(len=0, z2=z; *z2; z2++){ if( (0xc0&*z2)!=0x80 ) len++; }
if( p1<0 ){
p1 += len;
if( p1<0 ){
p2 += p1;
p1 = 0;
}
}else if( p1>0 ){
p1--;
}
if( p1+p2>len ){
p2 = len-p1;
}
for(i=0; i<p1 && z[i]; i++){
if( (z[i]&0xc0)==0x80 ) p1++;
}
while( z[i] && (z[i]&0xc0)==0x80 ){ i++; p1++; }
for(; i<p1+p2 && z[i]; i++){
if( (z[i]&0xc0)==0x80 ) p2++;
}
while( z[i] && (z[i]&0xc0)==0x80 ){ i++; p2++; }
if( p2<0 ) p2 = 0;
sqlite3_result_text(context, (char*)&z[p1], p2, SQLITE_TRANSIENT);
}
static void test_destructor(
sqlite3_context *pCtx,
int nArg,
sqlite3_value **argv
){
char *zVal;
int len;
test_destructor_count_var++;
assert( nArg==1 );
if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
len = sqlite3_value_bytes(argv[0]);
zVal = testContextMalloc(pCtx, len+3);
if( !zVal ){
return;
}
zVal[len+1] = 0;
zVal[len+2] = 0;
zVal++;
memcpy(zVal, sqlite3_value_text(argv[0]), len);
sqlite3_result_text(pCtx, zVal, -1, destructor);
}
static void string_reverse_implementation(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
const unsigned char* input = 0;
int input_type;
sqlite_uint64 input_length;
char* result;
int* decoded;
if (argc < 1) {
sqlite3_result_error(ctx, "not enough parameters", -1);
return;
}
if (argc > 1) {
sqlite3_result_error(ctx, "too many parameters", -1);
return;
}
input_type = sqlite3_value_type(argv[0]);
if (input_type != SQLITE_NULL) {
input = sqlite3_value_text(argv[0]);
}
if (input == 0) {
sqlite3_result_null(ctx);
return;
}
input_length = strlen_utf8(input);
result = sqlite3_malloc(4 * input_length + 1);
decoded = sqlite3_malloc(sizeof(int) * input_length);
decode_utf8(input, decoded);
reverse_string(decoded, result, input_length);
sqlite3_free(decoded);
sqlite3_result_text(ctx, result, -1, result_string_destructor);
}
static void ST_AsText(sqlite3_context *context, int nbArgs, sqlite3_value **args) {
spatialdb_t *spatialdb;
FUNCTION_GEOM_ARG(geomblob);
FUNCTION_START_STATIC(context, 256);
spatialdb = (spatialdb_t *)sqlite3_user_data(context);
FUNCTION_GET_GEOM_ARG_UNSAFE(context, spatialdb, geomblob, 0);
wkt_writer_t writer;
wkt_writer_init(&writer);
FUNCTION_RESULT = spatialdb->read_geometry(&FUNCTION_GEOM_ARG_STREAM(geomblob), wkt_writer_geom_consumer(&writer), FUNCTION_ERROR);
if (FUNCTION_RESULT == SQLITE_OK) {
sqlite3_result_text(context, wkt_writer_getwkt(&writer), (int) wkt_writer_length(&writer), SQLITE_TRANSIENT);
}
wkt_writer_destroy(&writer);
FUNCTION_END(context);
FUNCTION_FREE_GEOM_ARG(geomblob);
}
void geo_type(sqlite3_context *context,int argc,sqlite3_value **argv)
{
if(argc == 1 && sqlite3_value_type(argv[0]) == SQLITE_BLOB)
{
GEOSGeometry* geometry;
char* type;
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)
{
type = GEOSGeomType(geometry);
sqlite3_result_text(context,type,-1,SQLITE_TRANSIENT);
GEOSFree(type);
}
GEOSGeom_destroy(geometry);
finishGEOS();
}
}
static void
convert_lua_value_to_sqlite(lua_State *L, sqlite3_context *ctx)
{
switch(lua_type(L, -1)) {
case LUA_TSTRING: {
size_t length;
const char *value;
value = lua_tolstring(L, -1, &length);
sqlite3_result_text(ctx, value, length, SQLITE_TRANSIENT);
break;
}
case LUA_TNUMBER:
sqlite3_result_double(ctx, lua_tonumber(L, -1));
break;
case LUA_TBOOLEAN:
sqlite3_result_int(ctx, lua_toboolean(L, -1));
break;
case LUA_TNIL:
sqlite3_result_null(ctx);
break;
case LUA_TTABLE:
case LUA_TFUNCTION:
case LUA_TTHREAD:
case LUA_TUSERDATA: {
char *error = NULL;
error = sqlite3_mprintf("Invalid return type from lua(): %s", lua_typename(L, lua_type(L, -1)));
sqlite3_result_error(ctx, error, -1);
sqlite3_free(error);
}
}
lua_pop(L, 1);
}
