mirror of https://github.com/tstack/lnav
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1934 lines
51 KiB
C++
1934 lines
51 KiB
C++
/*
|
|
This library will provide common mathematical and string functions in
|
|
SQL queries using the operating system libraries or provided
|
|
definitions. It includes the following functions:
|
|
|
|
Math: acos, asin, atan, atn2, atan2, acosh, asinh, atanh, difference,
|
|
degrees, radians, cos, sin, tan, cot, cosh, sinh, tanh, coth, exp,
|
|
log, log10, power, sign, sqrt, square, ceil, floor, pi.
|
|
|
|
String: replicate, charindex, leftstr, rightstr, ltrim, rtrim, trim,
|
|
replace, reverse, proper, padl, padr, padc, strfilter.
|
|
|
|
Aggregate: stdev, variance, mode, median, lower_quartile,
|
|
upper_quartile.
|
|
|
|
The string functions ltrim, rtrim, trim, replace are included in
|
|
recent versions of SQLite and so by default do not build.
|
|
|
|
Compilation instructions:
|
|
Compile this C source file into a dynamic library as follows:
|
|
* Linux:
|
|
gcc -fPIC -lm -shared extension-functions.c -o libsqlitefunctions.so
|
|
* Mac OS X:
|
|
gcc -fno-common -dynamiclib extension-functions.c -o libsqlitefunctions.dylib
|
|
(You may need to add flags
|
|
-I /opt/local/include/ -L/opt/local/lib -lsqlite3
|
|
if your sqlite3 is installed from Mac ports, or
|
|
-I /sw/include/ -L/sw/lib -lsqlite3
|
|
if installed with Fink.)
|
|
* Windows:
|
|
1. Install MinGW (http://www.mingw.org/) and you will get the gcc
|
|
(gnu compiler collection)
|
|
2. add the path to your path variable (isn't done during the
|
|
installation!)
|
|
3. compile:
|
|
gcc -shared -I "path" -o libsqlitefunctions.so extension-functions.c
|
|
(path = path of sqlite3ext.h; i.e. C:\programs\sqlite)
|
|
|
|
Usage instructions for applications calling the sqlite3 API functions:
|
|
In your application, call sqlite3_enable_load_extension(db,1) to
|
|
allow loading external libraries. Then load the library libsqlitefunctions
|
|
using sqlite3_load_extension; the third argument should be 0.
|
|
See http://www.sqlite.org/cvstrac/wiki?p=LoadableExtensions.
|
|
Select statements may now use these functions, as in
|
|
SELECT cos(radians(inclination)) FROM satsum WHERE satnum = 25544;
|
|
|
|
Usage instructions for the sqlite3 program:
|
|
If the program is built so that loading extensions is permitted,
|
|
the following will work:
|
|
sqlite> SELECT load_extension('./libsqlitefunctions.so');
|
|
sqlite> select cos(radians(45));
|
|
0.707106781186548
|
|
Note: Loading extensions is by default prohibited as a
|
|
security measure; see "Security Considerations" in
|
|
http://www.sqlite.org/cvstrac/wiki?p=LoadableExtensions.
|
|
If the sqlite3 program and library are built this
|
|
way, you cannot use these functions from the program, you
|
|
must write your own program using the sqlite3 API, and call
|
|
sqlite3_enable_load_extension as described above, or else
|
|
rebuilt the sqlite3 program to allow loadable extensions.
|
|
|
|
Alterations:
|
|
The instructions are for Linux, Mac OS X, and Windows; users of other
|
|
OSes may need to modify this procedure. In particular, if your math
|
|
library lacks one or more of the needed trig or log functions, comment
|
|
out the appropriate HAVE_ #define at the top of file. If you do not
|
|
wish to make a loadable module, comment out the define for
|
|
COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE. If you are using a
|
|
version of SQLite without the trim functions and replace, comment out
|
|
the HAVE_TRIM #define.
|
|
|
|
Liam Healy
|
|
|
|
History:
|
|
2010-01-06 Correct check for argc in squareFunc, and add Windows
|
|
compilation instructions.
|
|
2009-06-24 Correct check for argc in properFunc.
|
|
2008-09-14 Add check that memory was actually allocated after
|
|
sqlite3_malloc or sqlite3StrDup, call sqlite3_result_error_nomem if
|
|
not. Thanks to Robert Simpson.
|
|
2008-06-13 Change to instructions to indicate use of the math library
|
|
and that program might work.
|
|
2007-10-01 Minor clarification to instructions.
|
|
2007-09-29 Compilation as loadable module is optional with
|
|
COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE.
|
|
2007-09-28 Use sqlite3_extension_init and macros
|
|
SQLITE_EXTENSION_INIT1, SQLITE_EXTENSION_INIT2, so that it works with
|
|
sqlite3_load_extension. Thanks to Eric Higashino and Joe Wilson.
|
|
New instructions for Mac compilation.
|
|
2007-09-17 With help from Joe Wilson and Nuno Luca, made use of
|
|
external interfaces so that compilation is no longer dependent on
|
|
SQLite source code. Merged source, header, and README into a single
|
|
file. Added casts so that Mac will compile without warnings (unsigned
|
|
and signed char).
|
|
2007-09-05 Included some definitions from sqlite 3.3.13 so that this
|
|
will continue to work in newer versions of sqlite. Completed
|
|
description of functions available.
|
|
2007-03-27 Revised description.
|
|
2007-03-23 Small cleanup and a bug fix on the code. This was mainly
|
|
letting errno flag errors encountered in the math library and checking
|
|
the result, rather than pre-checking. This fixes a bug in power that
|
|
would cause an error if any non-positive number was raised to any
|
|
power.
|
|
2007-02-07 posted by Mikey C to sqlite mailing list.
|
|
Original code 2006 June 05 by relicoder.
|
|
|
|
*/
|
|
|
|
//#include "config.h"
|
|
|
|
// #define COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE 1
|
|
#define HAVE_ACOSH 1
|
|
#define HAVE_ASINH 1
|
|
#define HAVE_ATANH 1
|
|
#define HAVE_SINH 1
|
|
#define HAVE_COSH 1
|
|
#define HAVE_TANH 1
|
|
#define HAVE_LOG10 1
|
|
#define HAVE_ISBLANK 1
|
|
#define SQLITE_SOUNDEX 1
|
|
#define HAVE_TRIM 1 /* LMH 2007-03-25 if sqlite has trim functions */
|
|
|
|
#define __STDC_FORMAT_MACROS
|
|
|
|
#ifdef COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE
|
|
#include "sqlite3ext.h"
|
|
SQLITE_EXTENSION_INIT1
|
|
#else
|
|
#include "sqlite3.h"
|
|
#endif
|
|
|
|
#include <ctype.h>
|
|
/* relicoder */
|
|
#include <math.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <errno.h> /* LMH 2007-03-25 */
|
|
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
|
|
#ifndef _MAP_H_
|
|
#define _MAP_H_
|
|
|
|
#include <stdint.h>
|
|
#include <inttypes.h>
|
|
|
|
#include "sqlite-extension-func.hh"
|
|
|
|
/*
|
|
** Simple binary tree implementation to use in median, mode and quartile calculations
|
|
** Tree is not necessarily balanced. That would require something like red&black trees of AVL
|
|
*/
|
|
|
|
typedef int(*cmp_func)(const void *, const void *);
|
|
typedef void(*map_iterator)(void*, int64_t, void*);
|
|
|
|
typedef struct node{
|
|
struct node *l;
|
|
struct node *r;
|
|
void* data;
|
|
int64_t count;
|
|
} node;
|
|
|
|
typedef struct map{
|
|
node *base;
|
|
cmp_func cmp;
|
|
short free;
|
|
} map;
|
|
|
|
/*
|
|
** creates a map given a comparison function
|
|
*/
|
|
map map_make(cmp_func cmp);
|
|
|
|
/*
|
|
** inserts the element e into map m
|
|
*/
|
|
void map_insert(map *m, void *e);
|
|
|
|
/*
|
|
** executes function iter over all elements in the map, in key increasing order
|
|
*/
|
|
void map_iterate(map *m, map_iterator iter, void* p);
|
|
|
|
/*
|
|
** frees all memory used by a map
|
|
*/
|
|
void map_destroy(map *m);
|
|
|
|
/*
|
|
** compares 2 integers
|
|
** to use with map_make
|
|
*/
|
|
int int_cmp(const void *a, const void *b);
|
|
|
|
/*
|
|
** compares 2 doubles
|
|
** to use with map_make
|
|
*/
|
|
int double_cmp(const void *a, const void *b);
|
|
|
|
#endif /* _MAP_H_ */
|
|
|
|
typedef uint8_t u8;
|
|
typedef uint16_t u16;
|
|
typedef int64_t i64;
|
|
|
|
static char *sqlite3StrDup( const char *z ) {
|
|
char *res = (char *) sqlite3_malloc(strlen(z) + 1 );
|
|
return strcpy( res, z );
|
|
}
|
|
|
|
/*
|
|
** These are copied verbatim from fun.c so as to not have the names exported
|
|
*/
|
|
|
|
/* LMH from sqlite3 3.3.13 */
|
|
/*
|
|
** This table maps from the first byte of a UTF-8 character to the number
|
|
** of trailing bytes expected. A value '4' indicates that the table key
|
|
** is not a legal first byte for a UTF-8 character.
|
|
*/
|
|
static const u8 xtra_utf8_bytes[256] = {
|
|
/* 0xxxxxxx */
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
/* 10wwwwww */
|
|
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
|
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
|
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
|
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
|
|
|
/* 110yyyyy */
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
|
|
/* 1110zzzz */
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
|
/* 11110yyy */
|
|
3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
|
|
};
|
|
|
|
|
|
/*
|
|
** This table maps from the number of trailing bytes in a UTF-8 character
|
|
** to an integer constant that is effectively calculated for each character
|
|
** read by a naive implementation of a UTF-8 character reader. The code
|
|
** in the READ_UTF8 macro explains things best.
|
|
*/
|
|
static const int xtra_utf8_bits[] = {
|
|
0,
|
|
12416, /* (0xC0 << 6) + (0x80) */
|
|
925824, /* (0xE0 << 12) + (0x80 << 6) + (0x80) */
|
|
63447168 /* (0xF0 << 18) + (0x80 << 12) + (0x80 << 6) + 0x80 */
|
|
};
|
|
|
|
/*
|
|
** If a UTF-8 character contains N bytes extra bytes (N bytes follow
|
|
** the initial byte so that the total character length is N+1) then
|
|
** masking the character with utf8_mask[N] must produce a non-zero
|
|
** result. Otherwise, we have an (illegal) overlong encoding.
|
|
*/
|
|
static const unsigned long utf_mask[] = {
|
|
0x00000000,
|
|
0xffffff80,
|
|
0xfffff800,
|
|
0xffff0000,
|
|
};
|
|
|
|
/* LMH salvaged from sqlite3 3.3.13 source code src/utf.c */
|
|
#define READ_UTF8(zIn, c) { \
|
|
int xtra; \
|
|
c = *(zIn)++; \
|
|
xtra = xtra_utf8_bytes[c]; \
|
|
switch( xtra ){ \
|
|
case 4: c = (int)0xFFFD; break; \
|
|
case 3: c = (c<<6) + *(zIn)++; \
|
|
case 2: c = (c<<6) + *(zIn)++; \
|
|
case 1: c = (c<<6) + *(zIn)++; \
|
|
c -= xtra_utf8_bits[xtra]; \
|
|
if( (utf_mask[xtra]&c)==0 \
|
|
|| (c&0xFFFFF800)==0xD800 \
|
|
|| (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \
|
|
} \
|
|
}
|
|
|
|
static int sqlite3ReadUtf8(const unsigned char *z){
|
|
int c;
|
|
READ_UTF8(z, c);
|
|
return c;
|
|
}
|
|
|
|
#define SKIP_UTF8(zIn) { \
|
|
zIn += (xtra_utf8_bytes[*(u8 *)zIn] + 1); \
|
|
}
|
|
|
|
/*
|
|
** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
|
|
** return the number of unicode characters in pZ up to (but not including)
|
|
** the first 0x00 byte. If nByte is not less than zero, return the
|
|
** number of unicode characters in the first nByte of pZ (or up to
|
|
** the first 0x00, whichever comes first).
|
|
*/
|
|
static int sqlite3Utf8CharLen(const char *z, int nByte){
|
|
int r = 0;
|
|
const char *zTerm;
|
|
if( nByte>=0 ){
|
|
zTerm = &z[nByte];
|
|
}else{
|
|
zTerm = (const char *)(-1);
|
|
}
|
|
assert( z<=zTerm );
|
|
while( *z!=0 && z<zTerm ){
|
|
SKIP_UTF8(z);
|
|
r++;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
** X is a pointer to the first byte of a UTF-8 character. Increment
|
|
** X so that it points to the next character. This only works right
|
|
** if X points to a well-formed UTF-8 string.
|
|
*/
|
|
#define sqliteNextChar(X) while( (0xc0&*++(X))==0x80 ){}
|
|
#define sqliteCharVal(X) sqlite3ReadUtf8(X)
|
|
|
|
/*
|
|
** This is a macro that facilitates writting wrappers for math.h functions
|
|
** it creates code for a function to use in SQlite that gets one numeric input
|
|
** and returns a floating point value.
|
|
**
|
|
** Could have been implemented using pointers to functions but this way it's inline
|
|
** and thus more efficient. Lower * ranking though...
|
|
**
|
|
** Parameters:
|
|
** name: function name to de defined (eg: sinFunc)
|
|
** function: function defined in math.h to wrap (eg: sin)
|
|
** domain: boolean condition that CAN'T happen in terms of the input parameter rVal
|
|
** (eg: rval<0 for sqrt)
|
|
*/
|
|
/* LMH 2007-03-25 Changed to use errno and remove domain; no pre-checking for errors. */
|
|
#define GEN_MATH_WRAP_DOUBLE_1(name, function) \
|
|
static void name(sqlite3_context *context, int argc, sqlite3_value **argv){\
|
|
double rVal = 0.0, val;\
|
|
assert( argc==1 );\
|
|
switch( sqlite3_value_type(argv[0]) ){\
|
|
case SQLITE_NULL: {\
|
|
sqlite3_result_null(context);\
|
|
break;\
|
|
}\
|
|
default: {\
|
|
rVal = sqlite3_value_double(argv[0]);\
|
|
errno = 0;\
|
|
val = function(rVal);\
|
|
if (errno == 0) {\
|
|
sqlite3_result_double(context, val);\
|
|
} else {\
|
|
sqlite3_result_error(context, strerror(errno), errno);\
|
|
}\
|
|
break;\
|
|
}\
|
|
}\
|
|
}\
|
|
|
|
|
|
/*
|
|
** Example of GEN_MATH_WRAP_DOUBLE_1 usage
|
|
** this creates function sqrtFunc to wrap the math.h standard function sqrt(x)=x^0.5
|
|
*/
|
|
GEN_MATH_WRAP_DOUBLE_1(sqrtFunc, sqrt)
|
|
|
|
/* trignometric functions */
|
|
GEN_MATH_WRAP_DOUBLE_1(acosFunc, acos)
|
|
GEN_MATH_WRAP_DOUBLE_1(asinFunc, asin)
|
|
GEN_MATH_WRAP_DOUBLE_1(atanFunc, atan)
|
|
|
|
/*
|
|
** Many of systems don't have inverse hyperbolic trig functions so this will emulate
|
|
** them on those systems in terms of log and sqrt (formulas are too trivial to demand
|
|
** written proof here)
|
|
*/
|
|
|
|
#ifndef HAVE_ACOSH
|
|
static double acosh(double x){
|
|
return log(x + sqrt(x*x - 1.0));
|
|
}
|
|
#endif
|
|
|
|
GEN_MATH_WRAP_DOUBLE_1(acoshFunc, acosh)
|
|
|
|
#ifndef HAVE_ASINH
|
|
static double asinh(double x){
|
|
return log(x + sqrt(x*x + 1.0));
|
|
}
|
|
#endif
|
|
|
|
GEN_MATH_WRAP_DOUBLE_1(asinhFunc, asinh)
|
|
|
|
#ifndef HAVE_ATANH
|
|
static double atanh(double x){
|
|
return (1.0/2.0)*log((1+x)/(1-x)) ;
|
|
}
|
|
#endif
|
|
|
|
GEN_MATH_WRAP_DOUBLE_1(atanhFunc, atanh)
|
|
|
|
/*
|
|
** math.h doesn't require cot (cotangent) so it's defined here
|
|
*/
|
|
static double cot(double x){
|
|
return 1.0/tan(x);
|
|
}
|
|
|
|
GEN_MATH_WRAP_DOUBLE_1(sinFunc, sin)
|
|
GEN_MATH_WRAP_DOUBLE_1(cosFunc, cos)
|
|
GEN_MATH_WRAP_DOUBLE_1(tanFunc, tan)
|
|
GEN_MATH_WRAP_DOUBLE_1(cotFunc, cot)
|
|
|
|
static double coth(double x){
|
|
return 1.0/tanh(x);
|
|
}
|
|
|
|
/*
|
|
** Many systems don't have hyperbolic trigonometric functions so this will emulate
|
|
** them on those systems directly from the definition in terms of exp
|
|
*/
|
|
#ifndef HAVE_SINH
|
|
static double sinh(double x){
|
|
return (exp(x)-exp(-x))/2.0;
|
|
}
|
|
#endif
|
|
|
|
GEN_MATH_WRAP_DOUBLE_1(sinhFunc, sinh)
|
|
|
|
#ifndef HAVE_COSH
|
|
static double cosh(double x){
|
|
return (exp(x)+exp(-x))/2.0;
|
|
}
|
|
#endif
|
|
|
|
GEN_MATH_WRAP_DOUBLE_1(coshFunc, cosh)
|
|
|
|
#ifndef HAVE_TANH
|
|
static double tanh(double x){
|
|
return sinh(x)/cosh(x);
|
|
}
|
|
#endif
|
|
|
|
GEN_MATH_WRAP_DOUBLE_1(tanhFunc, tanh)
|
|
|
|
GEN_MATH_WRAP_DOUBLE_1(cothFunc, coth)
|
|
|
|
/*
|
|
** Some systems lack log in base 10. This will emulate it
|
|
*/
|
|
|
|
#ifndef HAVE_LOG10
|
|
static double log10(double x){
|
|
static double l10 = -1.0;
|
|
if( l10<0.0 ){
|
|
l10 = log(10.0);
|
|
}
|
|
return log(x)/l10;
|
|
}
|
|
#endif
|
|
|
|
GEN_MATH_WRAP_DOUBLE_1(logFunc, log)
|
|
GEN_MATH_WRAP_DOUBLE_1(log10Func, log10)
|
|
GEN_MATH_WRAP_DOUBLE_1(expFunc, exp)
|
|
|
|
/*
|
|
** Fallback for systems where math.h doesn't define M_PI
|
|
*/
|
|
#undef M_PI
|
|
#ifndef M_PI
|
|
/*
|
|
** static double PI = acos(-1.0);
|
|
** #define M_PI (PI)
|
|
*/
|
|
#define M_PI 3.14159265358979323846
|
|
#endif
|
|
|
|
/* Convert Degrees into Radians */
|
|
static double deg2rad(double x){
|
|
return x*M_PI/180.0;
|
|
}
|
|
|
|
/* Convert Radians into Degrees */
|
|
static double rad2deg(double x){
|
|
return 180.0*x/M_PI;
|
|
}
|
|
|
|
GEN_MATH_WRAP_DOUBLE_1(rad2degFunc, rad2deg)
|
|
GEN_MATH_WRAP_DOUBLE_1(deg2radFunc, deg2rad)
|
|
|
|
/* constant function that returns the value of PI=3.1415... */
|
|
static void piFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
sqlite3_result_double(context, M_PI);
|
|
}
|
|
|
|
/*
|
|
** Implements the sqrt function, it has the peculiarity of returning an integer when the
|
|
** the argument is an integer.
|
|
** Since SQLite isn't strongly typed (almost untyped actually) this is a bit pedantic
|
|
*/
|
|
static void squareFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
i64 iVal = 0;
|
|
double rVal = 0.0;
|
|
assert( argc==1 );
|
|
switch( sqlite3_value_type(argv[0]) ){
|
|
case SQLITE_INTEGER: {
|
|
iVal = sqlite3_value_int64(argv[0]);
|
|
sqlite3_result_int64(context, iVal*iVal);
|
|
break;
|
|
}
|
|
case SQLITE_NULL: {
|
|
sqlite3_result_null(context);
|
|
break;
|
|
}
|
|
default: {
|
|
rVal = sqlite3_value_double(argv[0]);
|
|
sqlite3_result_double(context, rVal*rVal);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Wraps the pow math.h function
|
|
** When both the base and the exponent are integers the result should be integer
|
|
** (see sqrt just before this). Here the result is always double
|
|
*/
|
|
/* LMH 2007-03-25 Changed to use errno; no pre-checking for errors. Also removes
|
|
but that was present in the pre-checking that called sqlite3_result_error on
|
|
a non-positive first argument, which is not always an error. */
|
|
static void powerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
double r1 = 0.0;
|
|
double r2 = 0.0;
|
|
double val;
|
|
|
|
assert( argc==2 );
|
|
|
|
if( sqlite3_value_type(argv[0]) == SQLITE_NULL || sqlite3_value_type(argv[1]) == SQLITE_NULL ){
|
|
sqlite3_result_null(context);
|
|
}else{
|
|
r1 = sqlite3_value_double(argv[0]);
|
|
r2 = sqlite3_value_double(argv[1]);
|
|
errno = 0;
|
|
val = pow(r1,r2);
|
|
if (errno == 0) {
|
|
sqlite3_result_double(context, val);
|
|
} else {
|
|
sqlite3_result_error(context, strerror(errno), errno);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** atan2 wrapper
|
|
*/
|
|
static void atn2Func(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
double r1 = 0.0;
|
|
double r2 = 0.0;
|
|
|
|
assert( argc==2 );
|
|
|
|
if( sqlite3_value_type(argv[0]) == SQLITE_NULL || sqlite3_value_type(argv[1]) == SQLITE_NULL ){
|
|
sqlite3_result_null(context);
|
|
}else{
|
|
r1 = sqlite3_value_double(argv[0]);
|
|
r2 = sqlite3_value_double(argv[1]);
|
|
sqlite3_result_double(context, atan2(r1,r2));
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Implementation of the sign() function
|
|
** return one of 3 possibilities +1,0 or -1 when the argument is respectively
|
|
** positive, 0 or negative.
|
|
** When the argument is NULL the result is also NULL (completly conventional)
|
|
*/
|
|
static void signFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
double rVal=0.0;
|
|
i64 iVal=0;
|
|
assert( argc==1 );
|
|
switch( sqlite3_value_type(argv[0]) ){
|
|
case SQLITE_INTEGER: {
|
|
iVal = sqlite3_value_int64(argv[0]);
|
|
iVal = ( iVal > 0) ? 1: ( iVal < 0 ) ? -1: 0;
|
|
sqlite3_result_int64(context, iVal);
|
|
break;
|
|
}
|
|
case SQLITE_NULL: {
|
|
sqlite3_result_null(context);
|
|
break;
|
|
}
|
|
default: {
|
|
/* 2nd change below. Line for abs was: if( rVal<0 ) rVal = rVal * -1.0; */
|
|
|
|
rVal = sqlite3_value_double(argv[0]);
|
|
rVal = ( rVal > 0) ? 1: ( rVal < 0 ) ? -1: 0;
|
|
sqlite3_result_double(context, rVal);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** smallest integer value not less than argument
|
|
*/
|
|
static void ceilFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
double rVal=0.0;
|
|
assert( argc==1 );
|
|
switch( sqlite3_value_type(argv[0]) ){
|
|
case SQLITE_INTEGER: {
|
|
i64 iVal = sqlite3_value_int64(argv[0]);
|
|
sqlite3_result_int64(context, iVal);
|
|
break;
|
|
}
|
|
case SQLITE_NULL: {
|
|
sqlite3_result_null(context);
|
|
break;
|
|
}
|
|
default: {
|
|
rVal = sqlite3_value_double(argv[0]);
|
|
sqlite3_result_int64(context, (i64) ceil(rVal));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** largest integer value not greater than argument
|
|
*/
|
|
static void floorFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
double rVal=0.0;
|
|
assert( argc==1 );
|
|
switch( sqlite3_value_type(argv[0]) ){
|
|
case SQLITE_INTEGER: {
|
|
i64 iVal = sqlite3_value_int64(argv[0]);
|
|
sqlite3_result_int64(context, iVal);
|
|
break;
|
|
}
|
|
case SQLITE_NULL: {
|
|
sqlite3_result_null(context);
|
|
break;
|
|
}
|
|
default: {
|
|
rVal = sqlite3_value_double(argv[0]);
|
|
sqlite3_result_int64(context, (i64) floor(rVal));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Given a string (s) in the first argument and an integer (n) in the second returns the
|
|
** string that constains s contatenated n times
|
|
*/
|
|
static void replicateFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
unsigned char *z; /* input string */
|
|
unsigned char *zo; /* result string */
|
|
i64 iCount; /* times to repeat */
|
|
i64 nLen; /* length of the input string (no multibyte considerations) */
|
|
i64 nTLen; /* length of the result string (no multibyte considerations) */
|
|
i64 i=0;
|
|
|
|
if( argc!=2 || SQLITE_NULL==sqlite3_value_type(argv[0]) )
|
|
return;
|
|
|
|
iCount = sqlite3_value_int64(argv[1]);
|
|
|
|
if( iCount<0 ){
|
|
sqlite3_result_error(context, "domain error", -1);
|
|
}else{
|
|
|
|
nLen = sqlite3_value_bytes(argv[0]);
|
|
nTLen = nLen*iCount;
|
|
z= (unsigned char *) sqlite3_malloc(nTLen + 1);
|
|
zo= (unsigned char *) sqlite3_malloc(nLen + 1);
|
|
if (!z || !zo){
|
|
sqlite3_result_error_nomem(context);
|
|
if (z) sqlite3_free(z);
|
|
if (zo) sqlite3_free(zo);
|
|
return;
|
|
}
|
|
strcpy((char*)zo, (char*)sqlite3_value_text(argv[0]));
|
|
|
|
for(i=0; i<iCount; ++i){
|
|
strcpy((char*)(z+i*nLen), (char*)zo);
|
|
}
|
|
|
|
sqlite3_result_text(context, (char*)z, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(z);
|
|
sqlite3_free(zo);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Some systems (win32 among others) don't have an isblank function, this will emulate it.
|
|
** This function is not UFT-8 safe since it only analyses a byte character.
|
|
*/
|
|
#ifndef HAVE_ISBLANK
|
|
int isblank(char c){
|
|
return( ' '==c || '\t'==c );
|
|
}
|
|
#endif
|
|
|
|
static void properFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
const unsigned char *z; /* input string */
|
|
unsigned char *zo; /* output string */
|
|
unsigned char *zt; /* iterator */
|
|
char r;
|
|
int c=1;
|
|
|
|
assert( argc==1);
|
|
if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
|
|
sqlite3_result_null(context);
|
|
return;
|
|
}
|
|
|
|
z = sqlite3_value_text(argv[0]);
|
|
zo = (unsigned char *)sqlite3StrDup((char *) z);
|
|
if (!zo) {
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
zt = zo;
|
|
|
|
while( (r = *(z++))!=0 ){
|
|
if( isblank(r) ){
|
|
c=1;
|
|
}else{
|
|
if( c==1 ){
|
|
r = toupper(r);
|
|
}else{
|
|
r = tolower(r);
|
|
}
|
|
c=0;
|
|
}
|
|
*(zt++) = r;
|
|
}
|
|
*zt = '\0';
|
|
|
|
sqlite3_result_text(context, (char*)zo, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(zo);
|
|
}
|
|
|
|
/*
|
|
** given an input string (s) and an integer (n) adds spaces at the begining of s
|
|
** until it has a length of n characters.
|
|
** When s has a length >=n it's a NOP
|
|
** padl(NULL) = NULL
|
|
*/
|
|
static void padlFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
i64 ilen; /* length to pad to */
|
|
i64 zl; /* length of the input string (UTF-8 chars) */
|
|
int i = 0;
|
|
const char *zi; /* input string */
|
|
char *zo; /* output string */
|
|
char *zt;
|
|
|
|
assert( argc==2 );
|
|
|
|
if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
|
|
sqlite3_result_null(context);
|
|
}else{
|
|
zi = (char *)sqlite3_value_text(argv[0]);
|
|
ilen = sqlite3_value_int64(argv[1]);
|
|
/* check domain */
|
|
if(ilen<0){
|
|
sqlite3_result_error(context, "domain error", -1);
|
|
return;
|
|
}
|
|
zl = sqlite3Utf8CharLen(zi, -1);
|
|
if( zl>=ilen ){
|
|
/* string is longer than the requested pad length, return the same string (dup it) */
|
|
zo = sqlite3StrDup(zi);
|
|
if (!zo){
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
|
|
}else{
|
|
zo = (char *) sqlite3_malloc(strlen(zi) + ilen - zl + 1);
|
|
if (!zo){
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
zt = zo;
|
|
for(i=1; i+zl<=ilen; ++i){
|
|
*(zt++)=' ';
|
|
}
|
|
/* no need to take UTF-8 into consideration here */
|
|
strcpy(zt,zi);
|
|
}
|
|
sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(zo);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** given an input string (s) and an integer (n) appends spaces at the end of s
|
|
** until it has a length of n characters.
|
|
** When s has a length >=n it's a NOP
|
|
** padl(NULL) = NULL
|
|
*/
|
|
static void padrFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
i64 ilen; /* length to pad to */
|
|
i64 zl; /* length of the input string (UTF-8 chars) */
|
|
i64 zll; /* length of the input string (bytes) */
|
|
int i = 0;
|
|
const char *zi; /* input string */
|
|
char *zo; /* output string */
|
|
char *zt;
|
|
|
|
assert( argc==2 );
|
|
|
|
if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
|
|
sqlite3_result_null(context);
|
|
}else{
|
|
zi = (char *)sqlite3_value_text(argv[0]);
|
|
ilen = sqlite3_value_int64(argv[1]);
|
|
/* check domain */
|
|
if(ilen<0){
|
|
sqlite3_result_error(context, "domain error", -1);
|
|
return;
|
|
}
|
|
zl = sqlite3Utf8CharLen(zi, -1);
|
|
if( zl>=ilen ){
|
|
/* string is longer than the requested pad length, return the same string (dup it) */
|
|
zo = sqlite3StrDup(zi);
|
|
if (!zo){
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
|
|
}else{
|
|
zll = strlen(zi);
|
|
zo = (char *) sqlite3_malloc(zll + ilen - zl + 1);
|
|
if (!zo){
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
zt = strcpy(zo,zi)+zll;
|
|
for(i=1; i+zl<=ilen; ++i){
|
|
*(zt++) = ' ';
|
|
}
|
|
*zt = '\0';
|
|
}
|
|
sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(zo);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** given an input string (s) and an integer (n) appends spaces at the end of s
|
|
** and adds spaces at the begining of s until it has a length of n characters.
|
|
** Tries to add has many characters at the left as at the right.
|
|
** When s has a length >=n it's a NOP
|
|
** padl(NULL) = NULL
|
|
*/
|
|
static void padcFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
i64 ilen; /* length to pad to */
|
|
i64 zl; /* length of the input string (UTF-8 chars) */
|
|
i64 zll; /* length of the input string (bytes) */
|
|
int i = 0;
|
|
const char *zi; /* input string */
|
|
char *zo; /* output string */
|
|
char *zt;
|
|
|
|
assert( argc==2 );
|
|
|
|
if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
|
|
sqlite3_result_null(context);
|
|
}else{
|
|
zi = (char *)sqlite3_value_text(argv[0]);
|
|
ilen = sqlite3_value_int64(argv[1]);
|
|
/* check domain */
|
|
if(ilen<0){
|
|
sqlite3_result_error(context, "domain error", -1);
|
|
return;
|
|
}
|
|
zl = sqlite3Utf8CharLen(zi, -1);
|
|
if( zl>=ilen ){
|
|
/* string is longer than the requested pad length, return the same string (dup it) */
|
|
zo = sqlite3StrDup(zi);
|
|
if (!zo){
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
|
|
}else{
|
|
zll = strlen(zi);
|
|
zo = (char *) sqlite3_malloc(zll + ilen - zl + 1);
|
|
if (!zo){
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
zt = zo;
|
|
for(i=1; 2*i+zl<=ilen; ++i){
|
|
*(zt++) = ' ';
|
|
}
|
|
strcpy(zt, zi);
|
|
zt+=zll;
|
|
for(; i+zl<=ilen; ++i){
|
|
*(zt++) = ' ';
|
|
}
|
|
*zt = '\0';
|
|
}
|
|
sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(zo);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** given 2 string (s1,s2) returns the string s1 with the characters NOT in s2 removed
|
|
** assumes strings are UTF-8 encoded
|
|
*/
|
|
static void strfilterFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
const char *zi1; /* first parameter string (searched string) */
|
|
const char *zi2; /* second parameter string (vcontains valid characters) */
|
|
const char *z1;
|
|
const char *z21;
|
|
const char *z22;
|
|
char *zo; /* output string */
|
|
char *zot;
|
|
int c1 = 0;
|
|
int c2 = 0;
|
|
|
|
assert( argc==2 );
|
|
|
|
if( sqlite3_value_type(argv[0]) == SQLITE_NULL || sqlite3_value_type(argv[1]) == SQLITE_NULL ){
|
|
sqlite3_result_null(context);
|
|
}else{
|
|
zi1 = (char *)sqlite3_value_text(argv[0]);
|
|
zi2 = (char *)sqlite3_value_text(argv[1]);
|
|
/*
|
|
** maybe I could allocate less, but that would imply 2 passes, rather waste
|
|
** (possibly) some memory
|
|
*/
|
|
zo = (char *) sqlite3_malloc(strlen(zi1) + 1);
|
|
if (!zo){
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
zot = zo;
|
|
z1 = zi1;
|
|
while( (c1=sqliteCharVal((unsigned char *)z1))!=0 ){
|
|
z21=zi2;
|
|
while( (c2=sqliteCharVal((unsigned char *)z21))!=0 && c2!=c1 ){
|
|
sqliteNextChar(z21);
|
|
}
|
|
if( c2!=0){
|
|
z22=z21;
|
|
sqliteNextChar(z22);
|
|
strncpy(zot, z21, z22-z21);
|
|
zot+=z22-z21;
|
|
}
|
|
sqliteNextChar(z1);
|
|
}
|
|
*zot = '\0';
|
|
|
|
sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(zo);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Given a string z1, retutns the (0 based) index of it's first occurence
|
|
** in z2 after the first s characters.
|
|
** Returns -1 when there isn't a match.
|
|
** updates p to point to the character where the match occured.
|
|
** This is an auxiliary function.
|
|
*/
|
|
static int _substr(const char* z1, const char* z2, int s, const char** p){
|
|
int c = 0;
|
|
int rVal=-1;
|
|
const char* zt1;
|
|
const char* zt2;
|
|
int c1,c2;
|
|
|
|
if( '\0'==*z1 ){
|
|
return -1;
|
|
}
|
|
|
|
while( (sqliteCharVal((unsigned char *)z2) != 0) && (c++)<s){
|
|
sqliteNextChar(z2);
|
|
}
|
|
|
|
c = 0;
|
|
while( (sqliteCharVal((unsigned char *)z2)) != 0 ){
|
|
zt1 = z1;
|
|
zt2 = z2;
|
|
|
|
do{
|
|
c1 = sqliteCharVal((unsigned char *)zt1);
|
|
c2 = sqliteCharVal((unsigned char *)zt2);
|
|
sqliteNextChar(zt1);
|
|
sqliteNextChar(zt2);
|
|
}while( c1 == c2 && c1 != 0 && c2 != 0 );
|
|
|
|
if( c1 == 0 ){
|
|
rVal = c;
|
|
break;
|
|
}
|
|
|
|
sqliteNextChar(z2);
|
|
++c;
|
|
}
|
|
if(p){
|
|
*p=z2;
|
|
}
|
|
return rVal >=0 ? rVal+s : rVal;
|
|
}
|
|
|
|
/*
|
|
** given 2 input strings (s1,s2) and an integer (n) searches from the nth character
|
|
** for the string s1. Returns the position where the match occured.
|
|
** Characters are counted from 1.
|
|
** 0 is returned when no match occurs.
|
|
*/
|
|
|
|
static void charindexFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
const u8 *z1; /* s1 string */
|
|
u8 *z2; /* s2 string */
|
|
int s=0;
|
|
int rVal=0;
|
|
|
|
assert( argc==3 ||argc==2);
|
|
|
|
if( SQLITE_NULL==sqlite3_value_type(argv[0]) || SQLITE_NULL==sqlite3_value_type(argv[1])){
|
|
sqlite3_result_null(context);
|
|
return;
|
|
}
|
|
|
|
z1 = sqlite3_value_text(argv[0]);
|
|
if( z1==0 ) return;
|
|
z2 = (u8*) sqlite3_value_text(argv[1]);
|
|
if(argc==3){
|
|
s = sqlite3_value_int(argv[2])-1;
|
|
if(s<0){
|
|
s=0;
|
|
}
|
|
}else{
|
|
s = 0;
|
|
}
|
|
|
|
rVal = _substr((char *)z1,(char *)z2,s,NULL);
|
|
sqlite3_result_int(context, rVal+1);
|
|
}
|
|
|
|
/*
|
|
** given a string (s) and an integer (n) returns the n leftmost (UTF-8) characters
|
|
** if the string has a length<=n or is NULL this function is NOP
|
|
*/
|
|
static void leftFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
int c=0;
|
|
int cc=0;
|
|
int l=0;
|
|
const unsigned char *z; /* input string */
|
|
const unsigned char *zt;
|
|
unsigned char *rz; /* output string */
|
|
|
|
assert( argc==2);
|
|
|
|
if( SQLITE_NULL==sqlite3_value_type(argv[0]) || SQLITE_NULL==sqlite3_value_type(argv[1])){
|
|
sqlite3_result_null(context);
|
|
return;
|
|
}
|
|
|
|
z = sqlite3_value_text(argv[0]);
|
|
l = sqlite3_value_int(argv[1]);
|
|
zt = z;
|
|
|
|
while( sqliteCharVal(zt) && c++<l)
|
|
sqliteNextChar(zt);
|
|
|
|
cc=zt-z;
|
|
|
|
rz = (unsigned char *) sqlite3_malloc(zt - z + 1);
|
|
if (!rz){
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
strncpy((char*) rz, (char*) z, zt-z);
|
|
*(rz+cc) = '\0';
|
|
sqlite3_result_text(context, (char*)rz, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(rz);
|
|
}
|
|
|
|
/*
|
|
** given a string (s) and an integer (n) returns the n rightmost (UTF-8) characters
|
|
** if the string has a length<=n or is NULL this function is NOP
|
|
*/
|
|
static void rightFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
int l=0;
|
|
int c=0;
|
|
int cc=0;
|
|
const char *z;
|
|
const char *zt;
|
|
const char *ze;
|
|
char *rz;
|
|
|
|
assert( argc==2);
|
|
|
|
if( SQLITE_NULL == sqlite3_value_type(argv[0]) || SQLITE_NULL == sqlite3_value_type(argv[1])){
|
|
sqlite3_result_null(context);
|
|
return;
|
|
}
|
|
|
|
z = (char *)sqlite3_value_text(argv[0]);
|
|
l = sqlite3_value_int(argv[1]);
|
|
zt = z;
|
|
|
|
while( sqliteCharVal((unsigned char *)zt)!=0){
|
|
sqliteNextChar(zt);
|
|
++c;
|
|
}
|
|
|
|
ze = zt;
|
|
zt = z;
|
|
|
|
cc=c-l;
|
|
if(cc<0)
|
|
cc=0;
|
|
|
|
while( cc-- > 0 ){
|
|
sqliteNextChar(zt);
|
|
}
|
|
|
|
rz = (char *) sqlite3_malloc(ze - zt + 1);
|
|
if (!rz){
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
strcpy((char*) rz, (char*) (zt));
|
|
sqlite3_result_text(context, (char*)rz, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(rz);
|
|
}
|
|
|
|
#ifndef HAVE_TRIM
|
|
/*
|
|
** removes the whitespaces at the begining of a string.
|
|
*/
|
|
const char* ltrim(const char* s){
|
|
while( *s==' ' )
|
|
++s;
|
|
return s;
|
|
}
|
|
|
|
/*
|
|
** removes the whitespaces at the end of a string.
|
|
** !mutates the input string!
|
|
*/
|
|
void rtrim(char* s){
|
|
char* ss = s+strlen(s)-1;
|
|
while( ss>=s && *ss==' ' )
|
|
--ss;
|
|
*(ss+1)='\0';
|
|
}
|
|
|
|
/*
|
|
** Removes the whitespace at the begining of a string
|
|
*/
|
|
static void ltrimFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
const char *z;
|
|
|
|
assert( argc==1);
|
|
|
|
if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
|
|
sqlite3_result_null(context);
|
|
return;
|
|
}
|
|
z = sqlite3_value_text(argv[0]);
|
|
sqlite3_result_text(context, ltrim(z), -1, SQLITE_TRANSIENT);
|
|
}
|
|
|
|
/*
|
|
** Removes the whitespace at the end of a string
|
|
*/
|
|
static void rtrimFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
const char *z;
|
|
char *rz;
|
|
/* try not to change data in argv */
|
|
|
|
assert( argc==1);
|
|
|
|
if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
|
|
sqlite3_result_null(context);
|
|
return;
|
|
}
|
|
z = sqlite3_value_text(argv[0]);
|
|
rz = sqlite3StrDup(z);
|
|
rtrim(rz);
|
|
sqlite3_result_text(context, rz, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(rz);
|
|
}
|
|
|
|
/*
|
|
** Removes the whitespace at the begining and end of a string
|
|
*/
|
|
static void trimFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
const char *z;
|
|
char *rz;
|
|
/* try not to change data in argv */
|
|
|
|
assert( argc==1);
|
|
|
|
if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
|
|
sqlite3_result_null(context);
|
|
return;
|
|
}
|
|
z = sqlite3_value_text(argv[0]);
|
|
rz = sqlite3StrDup(z);
|
|
rtrim(rz);
|
|
sqlite3_result_text(context, ltrim(rz), -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(rz);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** given a pointer to a string s1, the length of that string (l1), a new string (s2)
|
|
** and it's length (l2) appends s2 to s1.
|
|
** All lengths in bytes.
|
|
** This is just an auxiliary function
|
|
*/
|
|
// static void _append(char **s1, int l1, const char *s2, int l2){
|
|
// *s1 = realloc(*s1, (l1+l2+1)*sizeof(char));
|
|
// strncpy((*s1)+l1, s2, l2);
|
|
// *(*(s1)+l1+l2) = '\0';
|
|
// }
|
|
|
|
#ifndef HAVE_TRIM
|
|
|
|
/*
|
|
** given strings s, s1 and s2 replaces occurrences of s1 in s by s2
|
|
*/
|
|
static void replaceFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
const char *z1; /* string s (first parameter) */
|
|
const char *z2; /* string s1 (second parameter) string to look for */
|
|
const char *z3; /* string s2 (third parameter) string to replace occurrences of s1 with */
|
|
int lz1;
|
|
int lz2;
|
|
int lz3;
|
|
int lzo=0;
|
|
char *zo=0;
|
|
int ret=0;
|
|
const char *zt1;
|
|
const char *zt2;
|
|
|
|
assert( 3==argc );
|
|
|
|
if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
|
|
sqlite3_result_null(context);
|
|
return;
|
|
}
|
|
|
|
z1 = sqlite3_value_text(argv[0]);
|
|
z2 = sqlite3_value_text(argv[1]);
|
|
z3 = sqlite3_value_text(argv[2]);
|
|
/* handle possible null values */
|
|
if( 0==z2 ){
|
|
z2="";
|
|
}
|
|
if( 0==z3 ){
|
|
z3="";
|
|
}
|
|
|
|
lz1 = strlen(z1);
|
|
lz2 = strlen(z2);
|
|
lz3 = strlen(z3);
|
|
|
|
#if 0
|
|
/* special case when z2 is empty (or null) nothing will be changed */
|
|
if( 0==lz2 ){
|
|
sqlite3_result_text(context, z1, -1, SQLITE_TRANSIENT);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
zt1=z1;
|
|
zt2=z1;
|
|
|
|
while(1){
|
|
ret=_substr(z2,zt1 , 0, &zt2);
|
|
|
|
if( ret<0 )
|
|
break;
|
|
|
|
_append(&zo, lzo, zt1, zt2-zt1);
|
|
lzo+=zt2-zt1;
|
|
_append(&zo, lzo, z3, lz3);
|
|
lzo+=lz3;
|
|
|
|
zt1=zt2+lz2;
|
|
}
|
|
_append(&zo, lzo, zt1, lz1-(zt1-z1));
|
|
sqlite3_result_text(context, zo, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(zo);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** given a string returns the same string but with the characters in reverse order
|
|
*/
|
|
static void reverseFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
const char *z;
|
|
const char *zt;
|
|
char *rz;
|
|
char *rzt;
|
|
int l = 0;
|
|
int i = 0;
|
|
|
|
assert( 1==argc );
|
|
|
|
if( SQLITE_NULL==sqlite3_value_type(argv[0]) ){
|
|
sqlite3_result_null(context);
|
|
return;
|
|
}
|
|
z = (char *)sqlite3_value_text(argv[0]);
|
|
l = strlen(z);
|
|
rz = (char *) sqlite3_malloc(l + 1);
|
|
if (!rz){
|
|
sqlite3_result_error_nomem(context);
|
|
return;
|
|
}
|
|
rzt = rz+l;
|
|
*(rzt--) = '\0';
|
|
|
|
zt=z;
|
|
while( sqliteCharVal((unsigned char *)zt)!=0 ){
|
|
z=zt;
|
|
sqliteNextChar(zt);
|
|
for(i=1; zt-i>=z; ++i){
|
|
*(rzt--)=*(zt-i);
|
|
}
|
|
}
|
|
|
|
sqlite3_result_text(context, rz, -1, SQLITE_TRANSIENT);
|
|
sqlite3_free(rz);
|
|
}
|
|
|
|
/*
|
|
** An instance of the following structure holds the context of a
|
|
** stdev() or variance() aggregate computation.
|
|
** implementaion of http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Algorithm_II
|
|
** less prone to rounding errors
|
|
*/
|
|
typedef struct StdevCtx StdevCtx;
|
|
struct StdevCtx {
|
|
double rM;
|
|
double rS;
|
|
i64 cnt; /* number of elements */
|
|
};
|
|
|
|
/*
|
|
** An instance of the following structure holds the context of a
|
|
** mode() or median() aggregate computation.
|
|
** Depends on structures defined in map.c (see map & map)
|
|
** These aggregate functions only work for integers and floats although
|
|
** they could be made to work for strings. This is usually considered meaningless.
|
|
** Only usuall order (for median), no use of collation functions (would this even make sense?)
|
|
*/
|
|
typedef struct ModeCtx ModeCtx;
|
|
struct ModeCtx {
|
|
i64 riM; /* integer value found so far */
|
|
double rdM; /* double value found so far */
|
|
i64 cnt; /* number of elements so far */
|
|
double pcnt; /* number of elements smaller than a percentile */
|
|
i64 mcnt; /* maximum number of occurrences (for mode) */
|
|
i64 mn; /* number of occurrences (for mode and percentiles) */
|
|
i64 is_double; /* whether the computation is being done for doubles (>0) or integers (=0) */
|
|
map* m; /* map structure used for the computation */
|
|
int done; /* whether the answer has been found */
|
|
};
|
|
|
|
/*
|
|
** called for each value received during a calculation of stdev or variance
|
|
*/
|
|
static void varianceStep(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
StdevCtx *p;
|
|
|
|
double delta;
|
|
double x;
|
|
|
|
assert( argc==1 );
|
|
p = (StdevCtx *) sqlite3_aggregate_context(context, sizeof(*p));
|
|
/* only consider non-null values */
|
|
if( SQLITE_NULL != sqlite3_value_numeric_type(argv[0]) ){
|
|
p->cnt++;
|
|
x = sqlite3_value_double(argv[0]);
|
|
delta = (x-p->rM);
|
|
p->rM += delta/p->cnt;
|
|
p->rS += delta*(x-p->rM);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** called for each value received during a calculation of mode of median
|
|
*/
|
|
static void modeStep(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
ModeCtx *p;
|
|
i64 xi=0;
|
|
double xd=0.0;
|
|
i64 *iptr;
|
|
double *dptr;
|
|
int type;
|
|
|
|
assert( argc==1 );
|
|
type = sqlite3_value_numeric_type(argv[0]);
|
|
|
|
if( type == SQLITE_NULL)
|
|
return;
|
|
|
|
p = (ModeCtx *) sqlite3_aggregate_context(context, sizeof(*p));
|
|
|
|
if( 0==(p->m) ){
|
|
p->m = (map *) calloc(1, sizeof(map));
|
|
if( type==SQLITE_INTEGER ){
|
|
/* map will be used for integers */
|
|
*(p->m) = map_make(int_cmp);
|
|
p->is_double = 0;
|
|
}else{
|
|
p->is_double = 1;
|
|
/* map will be used for doubles */
|
|
*(p->m) = map_make(double_cmp);
|
|
}
|
|
}
|
|
|
|
++(p->cnt);
|
|
|
|
if( 0==p->is_double ){
|
|
xi = sqlite3_value_int64(argv[0]);
|
|
iptr = (i64*)calloc(1,sizeof(i64));
|
|
*iptr = xi;
|
|
map_insert(p->m, iptr);
|
|
}else{
|
|
xd = sqlite3_value_double(argv[0]);
|
|
dptr = (double*)calloc(1,sizeof(double));
|
|
*dptr = xd;
|
|
map_insert(p->m, dptr);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Auxiliary function that iterates all elements in a map and finds the mode
|
|
** (most frequent value)
|
|
*/
|
|
static void modeIterate(void* e, i64 c, void* pp){
|
|
i64 ei;
|
|
double ed;
|
|
ModeCtx *p = (ModeCtx*)pp;
|
|
|
|
if( 0==p->is_double ){
|
|
ei = *(int*)(e);
|
|
|
|
if( p->mcnt==c ){
|
|
++p->mn;
|
|
}else if( p->mcnt<c ){
|
|
p->riM = ei;
|
|
p->mcnt = c;
|
|
p->mn=1;
|
|
}
|
|
}else{
|
|
ed = *(double*)(e);
|
|
|
|
if( p->mcnt==c ){
|
|
++p->mn;
|
|
}else if(p->mcnt<c){
|
|
p->rdM = ed;
|
|
p->mcnt = c;
|
|
p->mn=1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Auxiliary function that iterates all elements in a map and finds the median
|
|
** (the value such that the number of elements smaller is equal the the number of
|
|
** elements larger)
|
|
*/
|
|
static void medianIterate(void* e, i64 c, void* pp){
|
|
i64 ei;
|
|
double ed;
|
|
double iL;
|
|
double iR;
|
|
int il;
|
|
int ir;
|
|
ModeCtx *p = (ModeCtx*)pp;
|
|
|
|
if(p->done>0)
|
|
return;
|
|
|
|
iL = p->pcnt;
|
|
iR = p->cnt - p->pcnt;
|
|
il = p->mcnt + c;
|
|
ir = p->cnt - p->mcnt;
|
|
|
|
if( il >= iL ){
|
|
if( ir >= iR ){
|
|
++p->mn;
|
|
if( 0==p->is_double ){
|
|
ei = *(int*)(e);
|
|
p->riM += ei;
|
|
}else{
|
|
ed = *(double*)(e);
|
|
p->rdM += ed;
|
|
}
|
|
}else{
|
|
p->done=1;
|
|
}
|
|
}
|
|
p->mcnt+=c;
|
|
}
|
|
|
|
/*
|
|
** Returns the mode value
|
|
*/
|
|
static void modeFinalize(sqlite3_context *context){
|
|
ModeCtx *p;
|
|
p = (ModeCtx *) sqlite3_aggregate_context(context, 0);
|
|
if( p && p->m ){
|
|
map_iterate(p->m, modeIterate, p);
|
|
map_destroy(p->m);
|
|
free(p->m);
|
|
|
|
if( 1==p->mn ){
|
|
if( 0==p->is_double )
|
|
sqlite3_result_int64(context, p->riM);
|
|
else
|
|
sqlite3_result_double(context, p->rdM);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** auxiliary function for percentiles
|
|
*/
|
|
static void _medianFinalize(sqlite3_context *context){
|
|
ModeCtx *p;
|
|
p = (ModeCtx*) sqlite3_aggregate_context(context, 0);
|
|
if( p && p->m ){
|
|
p->done=0;
|
|
map_iterate(p->m, medianIterate, p);
|
|
map_destroy(p->m);
|
|
free(p->m);
|
|
|
|
if( 0==p->is_double )
|
|
if( 1==p->mn )
|
|
sqlite3_result_int64(context, p->riM);
|
|
else
|
|
sqlite3_result_double(context, p->riM*1.0/p->mn);
|
|
else
|
|
sqlite3_result_double(context, p->rdM/p->mn);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Returns the median value
|
|
*/
|
|
static void medianFinalize(sqlite3_context *context){
|
|
ModeCtx *p;
|
|
p = (ModeCtx*) sqlite3_aggregate_context(context, 0);
|
|
if( p!=0 ){
|
|
p->pcnt = (p->cnt)/2.0;
|
|
_medianFinalize(context);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Returns the lower_quartile value
|
|
*/
|
|
static void lower_quartileFinalize(sqlite3_context *context){
|
|
ModeCtx *p;
|
|
p = (ModeCtx*) sqlite3_aggregate_context(context, 0);
|
|
if( p!=0 ){
|
|
p->pcnt = (p->cnt)/4.0;
|
|
_medianFinalize(context);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Returns the upper_quartile value
|
|
*/
|
|
static void upper_quartileFinalize(sqlite3_context *context){
|
|
ModeCtx *p;
|
|
p = (ModeCtx*) sqlite3_aggregate_context(context, 0);
|
|
if( p!=0 ){
|
|
p->pcnt = (p->cnt)*3/4.0;
|
|
_medianFinalize(context);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Returns the stdev value
|
|
*/
|
|
static void stdevFinalize(sqlite3_context *context){
|
|
StdevCtx *p;
|
|
p = (StdevCtx *) sqlite3_aggregate_context(context, 0);
|
|
if( p && p->cnt>1 ){
|
|
sqlite3_result_double(context, sqrt(p->rS/(p->cnt-1)));
|
|
}else{
|
|
sqlite3_result_double(context, 0.0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Returns the variance value
|
|
*/
|
|
static void varianceFinalize(sqlite3_context *context){
|
|
StdevCtx *p;
|
|
p = (StdevCtx *) sqlite3_aggregate_context(context, 0);
|
|
if( p && p->cnt>1 ){
|
|
sqlite3_result_double(context, p->rS/(p->cnt-1));
|
|
}else{
|
|
sqlite3_result_double(context, 0.0);
|
|
}
|
|
}
|
|
|
|
#ifdef SQLITE_SOUNDEX
|
|
|
|
/* relicoder factored code */
|
|
/*
|
|
** Calculates the soundex value of a string
|
|
*/
|
|
|
|
static void soundex(const u8 *zIn, char *zResult){
|
|
int i, j;
|
|
static const unsigned char iCode[] = {
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
|
|
1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
|
|
0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
|
|
1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
|
|
};
|
|
|
|
for(i=0; zIn[i] && !isalpha(zIn[i]); i++){}
|
|
if( zIn[i] ){
|
|
zResult[0] = toupper(zIn[i]);
|
|
for(j=1; j<4 && zIn[i]; i++){
|
|
int code = iCode[zIn[i]&0x7f];
|
|
if( code>0 ){
|
|
zResult[j++] = code + '0';
|
|
}
|
|
}
|
|
while( j<4 ){
|
|
zResult[j++] = '0';
|
|
}
|
|
zResult[j] = 0;
|
|
}else{
|
|
strcpy(zResult, "?000");
|
|
}
|
|
}
|
|
|
|
/*
|
|
** computes the number of different characters between the soundex value fo 2 strings
|
|
*/
|
|
static void differenceFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
|
|
char zResult1[8];
|
|
char zResult2[8];
|
|
char *zR1 = zResult1;
|
|
char *zR2 = zResult2;
|
|
int rVal = 0;
|
|
int i = 0;
|
|
const u8 *zIn1;
|
|
const u8 *zIn2;
|
|
|
|
assert( argc==2 );
|
|
|
|
if( sqlite3_value_type(argv[0])==SQLITE_NULL || sqlite3_value_type(argv[1])==SQLITE_NULL ){
|
|
sqlite3_result_null(context);
|
|
return;
|
|
}
|
|
|
|
zIn1 = (u8*)sqlite3_value_text(argv[0]);
|
|
zIn2 = (u8*)sqlite3_value_text(argv[1]);
|
|
|
|
soundex(zIn1, zR1);
|
|
soundex(zIn2, zR2);
|
|
|
|
for(i=0; i<4; ++i){
|
|
if( sqliteCharVal((unsigned char *)zR1)==sqliteCharVal((unsigned char *)zR2) )
|
|
++rVal;
|
|
sqliteNextChar(zR1);
|
|
sqliteNextChar(zR2);
|
|
}
|
|
sqlite3_result_int(context, rVal);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
** This function registered all of the above C functions as SQL
|
|
** functions. This should be the only routine in this file with
|
|
** external linkage.
|
|
*/
|
|
int common_extension_functions(struct FuncDef **basic_funcs,
|
|
struct FuncDefAgg **agg_funcs) {
|
|
static struct FuncDef aFuncs[] = {
|
|
/* math.h */
|
|
{ "acos", 1, SQLITE_UTF8, 0, acosFunc },
|
|
{ "asin", 1, SQLITE_UTF8, 0, asinFunc },
|
|
{ "atan", 1, SQLITE_UTF8, 0, atanFunc },
|
|
{ "atn2", 2, SQLITE_UTF8, 0, atn2Func },
|
|
/* XXX alias */
|
|
{ "atan2", 2, SQLITE_UTF8, 0, atn2Func },
|
|
{ "acosh", 1, SQLITE_UTF8, 0, acoshFunc },
|
|
{ "asinh", 1, SQLITE_UTF8, 0, asinhFunc },
|
|
{ "atanh", 1, SQLITE_UTF8, 0, atanhFunc },
|
|
|
|
{ "difference", 2, SQLITE_UTF8, 0, differenceFunc},
|
|
{ "degrees", 1, SQLITE_UTF8, 0, rad2degFunc },
|
|
{ "radians", 1, SQLITE_UTF8, 0, deg2radFunc },
|
|
|
|
{ "cos", 1, SQLITE_UTF8, 0, cosFunc },
|
|
{ "sin", 1, SQLITE_UTF8, 0, sinFunc },
|
|
{ "tan", 1, SQLITE_UTF8, 0, tanFunc },
|
|
{ "cot", 1, SQLITE_UTF8, 0, cotFunc },
|
|
{ "cosh", 1, SQLITE_UTF8, 0, coshFunc },
|
|
{ "sinh", 1, SQLITE_UTF8, 0, sinhFunc },
|
|
{ "tanh", 1, SQLITE_UTF8, 0, tanhFunc },
|
|
{ "coth", 1, SQLITE_UTF8, 0, cothFunc },
|
|
|
|
{ "exp", 1, SQLITE_UTF8, 0, expFunc },
|
|
{ "log", 1, SQLITE_UTF8, 0, logFunc },
|
|
{ "log10", 1, SQLITE_UTF8, 0, log10Func },
|
|
{ "power", 2, SQLITE_UTF8, 0, powerFunc },
|
|
{ "sign", 1, SQLITE_UTF8, 0, signFunc },
|
|
{ "sqrt", 1, SQLITE_UTF8, 0, sqrtFunc },
|
|
{ "square", 1, SQLITE_UTF8, 0, squareFunc },
|
|
|
|
{ "ceil", 1, SQLITE_UTF8, 0, ceilFunc },
|
|
{ "floor", 1, SQLITE_UTF8, 0, floorFunc },
|
|
|
|
{ "pi", 0, SQLITE_UTF8, 1, piFunc },
|
|
|
|
|
|
/* string */
|
|
{ "replicate", 2, SQLITE_UTF8, 0, replicateFunc,
|
|
help_text("replicate")
|
|
.sql_function()
|
|
.with_summary("Returns the given string concatenated N times.")
|
|
.with_parameter({"str", "The string to replicate."})
|
|
.with_parameter({"N", "The number of times to replicate the string."})
|
|
.with_example({"SELECT replicate('abc', 3)"})
|
|
},
|
|
{ "charindex", 2, SQLITE_UTF8, 0, charindexFunc },
|
|
{ "charindex", 3, SQLITE_UTF8, 0, charindexFunc },
|
|
{ "leftstr", 2, SQLITE_UTF8, 0, leftFunc,
|
|
help_text("leftstr")
|
|
.sql_function()
|
|
.with_summary("Returns the N leftmost (UTF-8) characters in the given string.")
|
|
.with_parameter({"str", "The string to return subset."})
|
|
.with_parameter({"N", "The number of characters from the left side of the string to return."})
|
|
.with_example({"SELECT leftstr('abc', 1)"})
|
|
.with_example({"SELECT leftstr('abc', 10)"})
|
|
},
|
|
{ "rightstr", 2, SQLITE_UTF8, 0, rightFunc,
|
|
help_text("rightstr")
|
|
.sql_function()
|
|
.with_summary("Returns the N rightmost (UTF-8) characters in the given string.")
|
|
.with_parameter({"str", "The string to return subset."})
|
|
.with_parameter({"N", "The number of characters from the right side of the string to return."})
|
|
.with_example({"SELECT rightstr('abc', 1)"})
|
|
.with_example({"SELECT rightstr('abc', 10)"})
|
|
},
|
|
#ifndef HAVE_TRIM
|
|
{ "ltrim", 1, SQLITE_UTF8, 0, ltrimFunc },
|
|
{ "rtrim", 1, SQLITE_UTF8, 0, rtrimFunc },
|
|
{ "trim", 1, SQLITE_UTF8, 0, trimFunc },
|
|
{ "replace", 3, SQLITE_UTF8, 0, replaceFunc },
|
|
#endif
|
|
{ "reverse", 1, SQLITE_UTF8, 0, reverseFunc,
|
|
help_text("reverse")
|
|
.sql_function()
|
|
.with_summary("Returns the reverse of the given string.")
|
|
.with_parameter({"str", "The string to reverse."})
|
|
.with_example({"SELECT reverse('abc')"})
|
|
},
|
|
{ "proper", 1, SQLITE_UTF8, 0, properFunc },
|
|
{ "padl", 2, SQLITE_UTF8, 0, padlFunc },
|
|
{ "padr", 2, SQLITE_UTF8, 0, padrFunc },
|
|
{ "padc", 2, SQLITE_UTF8, 0, padcFunc },
|
|
{ "strfilter", 2, SQLITE_UTF8, 0, strfilterFunc },
|
|
|
|
{ NULL }
|
|
};
|
|
|
|
/* Aggregate functions */
|
|
static struct FuncDefAgg aAggs[] = {
|
|
{ "stdev", 1, 0, varianceStep, stdevFinalize },
|
|
{ "stddev", 1, 0, varianceStep, stdevFinalize },
|
|
{ "variance", 1, 0, varianceStep, varianceFinalize },
|
|
{ "mode", 1, 0, modeStep, modeFinalize },
|
|
{ "median", 1, 0, modeStep, medianFinalize },
|
|
{ "lower_quartile", 1, 0, modeStep, lower_quartileFinalize },
|
|
{ "upper_quartile", 1, 0, modeStep, upper_quartileFinalize },
|
|
|
|
{ NULL }
|
|
};
|
|
|
|
*basic_funcs = aFuncs;
|
|
*agg_funcs = aAggs;
|
|
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
#ifdef COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE
|
|
int sqlite3_extension_init(
|
|
sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi){
|
|
SQLITE_EXTENSION_INIT2(pApi);
|
|
RegisterExtensionFunctions(db);
|
|
return 0;
|
|
}
|
|
#endif /* COMPILE_SQLITE_EXTENSIONS_AS_LOADABLE_MODULE */
|
|
|
|
map map_make(cmp_func cmp){
|
|
map r;
|
|
r.cmp=cmp;
|
|
r.base = 0;
|
|
r.free = 0;
|
|
|
|
return r;
|
|
}
|
|
|
|
void* xcalloc(size_t nmemb, size_t size, const char* s){
|
|
void* ret = calloc(nmemb, size);
|
|
return ret;
|
|
}
|
|
|
|
static void xfree(void* p){
|
|
free(p);
|
|
}
|
|
|
|
void node_insert(node** n, cmp_func cmp, void *e){
|
|
int c;
|
|
node* nn;
|
|
if(*n==0){
|
|
nn = (node*)xcalloc(1,sizeof(node), "for node");
|
|
nn->data = e;
|
|
nn->count = 1;
|
|
*n=nn;
|
|
}else{
|
|
c=cmp((*n)->data,e);
|
|
if(0==c){
|
|
++((*n)->count);
|
|
xfree(e);
|
|
}else if(c>0){
|
|
/* put it right here */
|
|
node_insert(&((*n)->l), cmp, e);
|
|
}else{
|
|
node_insert(&((*n)->r), cmp, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
void map_insert(map *m, void *e){
|
|
node_insert(&(m->base), m->cmp, e);
|
|
}
|
|
|
|
void node_iterate(node *n, map_iterator iter, void* p){
|
|
if(n){
|
|
if(n->l)
|
|
node_iterate(n->l, iter, p);
|
|
iter(n->data, n->count, p);
|
|
if(n->r)
|
|
node_iterate(n->r, iter, p);
|
|
}
|
|
}
|
|
|
|
void map_iterate(map *m, map_iterator iter, void* p){
|
|
node_iterate(m->base, iter, p);
|
|
}
|
|
|
|
void node_destroy(node *n){
|
|
if(0!=n){
|
|
xfree(n->data);
|
|
if(n->l)
|
|
node_destroy(n->l);
|
|
if(n->r)
|
|
node_destroy(n->r);
|
|
|
|
xfree(n);
|
|
}
|
|
}
|
|
|
|
void map_destroy(map *m){
|
|
node_destroy(m->base);
|
|
}
|
|
|
|
int int_cmp(const void *a, const void *b){
|
|
int64_t aa = *(int64_t *)(a);
|
|
int64_t bb = *(int64_t *)(b);
|
|
/* printf("cmp %d <=> %d\n",aa,bb); */
|
|
if(aa==bb)
|
|
return 0;
|
|
else if(aa<bb)
|
|
return -1;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
int double_cmp(const void *a, const void *b){
|
|
double aa = *(double *)(a);
|
|
double bb = *(double *)(b);
|
|
/* printf("cmp %d <=> %d\n",aa,bb); */
|
|
if(aa==bb)
|
|
return 0;
|
|
else if(aa<bb)
|
|
return -1;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
void print_elem(void *e, int64_t c, void* p){
|
|
int ee = *(int*)(e);
|
|
printf("%d => %" PRId64 "\n", ee,c);
|
|
}
|
|
|