text: /*
  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 */
  
  #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>
  
  #ifdef _WIN32
  #include <windows.h>
  #define strcasecmp  _stricmp
  #define strncasecmp _strnicmp
  #endif
  
  
  /*
  ** 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 = 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 int 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;
    i64 iVal=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;
    i64 iVal=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;
      }
    }
  }
  
  /*
  ** largest integer value not greater than argument
  */
  static void fromHexFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
    double rVal=0.0;
    assert( argc==1 );
    const char* hexstr = sqlite3_value_text(argv[0]);
    i64 hexVal = strtol(hexstr, NULL, 0);
    sqlite3_result_int64(context, hexVal);
  }
  
  /*
  ** 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=sqlite3_malloc(nTLen+1);
      zo=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 = 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 = 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 = 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 = 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);
    }
  }
  //select substring_index("test","e",1)
  // from https://github.com/mysql/mysql-server/blob/ee4455a33b10f1b1886044322e4893f587b319ed/sql/item_strfunc.cc
  static void substr_indexFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
    const char *res;        /* first parameter string (searched string) */
    int res_length;
    const char *delimiter;        /* second parameter string (vcontains valid characters) */
    char *tmp;               /* output string */
    int delimiter_length;
    int count_val=0;
    
  
    assert( argc==3 );
    
    if( sqlite3_value_type(argv[0]) == SQLITE_NULL || sqlite3_value_type(argv[1]) == SQLITE_NULL ){
      sqlite3_result_null(context); 
      return;
    }
    res = (char *)sqlite3_value_text(argv[0]);
  	res_length = sqlite3_value_bytes(argv[0]);
    delimiter = (char *)sqlite3_value_text(argv[1]);
    delimiter_length = sqlite3_value_bytes(argv[1]);
  	count_val  = sqlite3_value_int(argv[2]);
      
    int offset=0;
    const int end = res_length - delimiter_length + 1;
    
    long nnn = 0;
    long ccc = count_val;
    for (int pass = (count_val < 0 ? 0 : 1); pass < 2; ++pass) {
      while (offset < end) {
        if (startsWith(res+offset, delimiter)) {
          int i = 0;
          while (i != delimiter_length) {
            i++;
            if (*(i+delimiter) != *(i+delimiter)) goto skip;
          }
          if (pass == 0)
            ++nnn;
          else if (--ccc == 0)
            break;
          offset += delimiter_length;
          continue;
        }
      skip:
        offset ++; //max(1U, my_ismbchar(res->charset(), ptr, strend));
      } /* either not found or got total number when count<0 */
  
      if (pass == 0) /* count < 0 */
      {
        ccc += nnn + 1;
        if (ccc <= 0){
          tmp=res;/* not found, return original string */
          break;
        }
        offset=0;
      } else {
        if (ccc != 0){
          tmp=res;/* not found, return original string */
          break;
        } 
        if (count_val < 0) /* return right part */
        {
          tmp = sqlite3_malloc(res_length-offset-delimiter_length+1); 
          if (!tmp){
            sqlite3_result_error_nomem(context);
            return;
          }
          strncpy((char *)tmp,(char *)(res+offset+delimiter_length),res_length-offset-delimiter_length);
          tmp[res_length-offset-delimiter_length]='\0';
        } else /* return left part */
        {
          tmp = sqlite3_malloc(offset+1); 
          if (!tmp){
            sqlite3_result_error_nomem(context);
            return;
          }
          strncpy((char *)tmp,(char *)(res),offset);
          tmp[offset]='\0';
          //tmp_value.set(*res, 0, (ptr - res->ptr()));
        }
      }
    }    
    sqlite3_result_text(context, (char*)tmp, -1, SQLITE_TRANSIENT);
  }
  
  /**
   ** Converts a string-formatted storage value into MB
   ** Ex: select mt_capacity_to_mb("sdfh sj 97,705.94 KB")
   **
   **/
  static void mt_capacity_to_mbFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  
    char *str;
    int strLength;
    char *result;
  
    if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
      // input is null - return null
      sqlite3_result_null(context); 
      return;
    }
  
    str = (char *)sqlite3_value_text(argv[0]);
  	strLength = sqlite3_value_bytes(argv[0]);
    result = sqlite3_malloc(strLength+1);
  
    int numSize = 0;
    char *c;
    int foundNum = 0;
    
    for (c = str; *c != '\0'; c++) {
        if (isdigit(*c) || (*c == '.' && isdigit(*(c+1)))) {
            numSize++;
        }
    }
  
    if( numSize == 0 ){
      // input contains no numbers - return null
      sqlite3_result_null(context); 
      return;
    }
    
    char *num = sqlite3_malloc(numSize + 1);
    int numIdx = 0;
    char *unit = sqlite3_malloc(3);
    int unitIdx = 0;
    char *unitChars = "bkmgtpe";
    
    for (c = str; *c != '\0'; c++) {
        if (isdigit(*c) || (*c == '.' && isdigit(*(c+1)))) {
            if (!foundNum) {
                foundNum = 1;
            }
            num[numIdx] = *c;
            numIdx++;
        } else if (foundNum && unitIdx < 2 && strchr(unitChars, tolower(*c)) != NULL) {
            unit[unitIdx] = tolower(*c);
            unitIdx++;
        }
    }
    
    num[numIdx] = '\0';
    unit[unitIdx] = '\0';
    int unitLength = strlen(unit);
    float parsedNum = strtof(num, NULL);
    
    if (unitLength > 1) {
        if (unit[0] == 'k') {
            parsedNum = parsedNum / 1024;
        } else if (unit[0] == 'm') {
            parsedNum = parsedNum;
        } else if (unit[0] == 'g') {
            parsedNum = parsedNum * 1024;
        } else if (unit[0] == 't') {
            parsedNum = parsedNum * 1024 * 1024;
        } else if (unit[0] == 'p') {
            parsedNum = parsedNum * 1024 * 1024 * 1024;
        } else if (unit[0] == 'e') {
            parsedNum = parsedNum * 1024 * 1024 * 1024 * 1024;
        }
    } else {
        // default: B
        parsedNum = parsedNum / 1024 / 1024;
    }
  
    sqlite3_result_double(context, parsedNum, -1, SQLITE_TRANSIENT);
  }
  
  static char* doubleToString(double num) {
    char *str = sqlite3_malloc(10);
    sprintf(str, "%.0f", num);
    return str;
  }
  
  /**
   ** Converts number of days into a retention period (i.e. string)
   ** Ex: SELECT mt_num_days_to_age("23", "Data Protector")
   ** Ex: 30 --> 4 weeks
   ** Ex: 92 --> 3 months
   ** Ex: 7  --> 1 week
   **/
  static void mt_num_days_to_ageFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  
    double daysInput;
    int isDaysInputNull = 0;
    double days = -1;
    double weeks = -1;
    double months = -1;
    double years = -1;
    char *result;
    char *platform;
  
    if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
      isDaysInputNull = 1;
    }
  
    daysInput = sqlite3_value_double(argv[0]);
    platform = sqlite3_value_text(argv[1]);
  
    if ( daysInput >= 7 && daysInput/7 < 9) {
  		weeks = round(daysInput/7);
    } else if (daysInput <= 27) {
      days = daysInput;
    } else if (daysInput > 350) {
      years = round(daysInput/365);
    } else {
      years = -1;
    }
  
  	if (daysInput - (years < 0 ? 0 : years * 365) > 27) {
      months = round((daysInput - (years < 0 ? 0 : years)*365)/30 );  
    } else {
      months = -1;
    }
  
    if (daysInput < 0 && strcmp(platform, "NetBackup") == 0) {
      result = "Infinity";
    }	else if (daysInput < 0 && strcmp(platform, "CommVault") == 0) {
      result = "Infinity";
    }	else if (strcmp(platform, "NetBackup") == 0 && years > 22) {
      result = "Infinity";
    }	else if (strcmp(platform, "Data Protector") == 0 && isDaysInputNull) {
      result = "Protected Permanently";
    }	else if (strcmp(platform, "Data Protector") == 0 && daysInput < 0) {
      result = "Not Protected";
    }	else if (days == 1) {
      result = "1 Day";
    }	else if (days >= 0) {
      result = strcat(doubleToString(days), " Days");
    }	else if (weeks == 1) {
      result = "1 Week";
    }	else if (weeks >= 0) {
      result = strcat(doubleToString(weeks), " Weeks");
    }	else if (years == 1 && months == 1) {
      result = "1 Year, 1 Month";
    }	else if (years == 1 && months >= 0) {
      result = strcat(strcat("1 Year, ", doubleToString(months)), " Months");
    }	else if (years >= 0 && months == 1) {
      result = strcat(strcat(doubleToString(years), " Years, ")," 1 Month");
    }	else if (years >= 0 && months >= 0) {
      result = strcat(strcat(strcat(doubleToString(years), " Years, "), doubleToString(months)), " Months");
    }	else if (years == 1) {
      result = "1 Year";
    }	else if (years >= 0) {
      result = strcat(doubleToString(years), " Years");
    }	else if (months == 1) {
      result = "1 Month";
    }	else if (months >= 0) {
      result = strcat(doubleToString(months), " Months");
    } else {
      result = "Unknown";
    }
  
    sqlite3_result_text(context, (char*)result, -1, SQLITE_TRANSIENT);
  
  }
  
  /**
   ** Truncates a hostname
   ** Ex: select mt_truncate_host("phl-nw05.dhe.duke.edu") --> phl-nw05
   ** Ex: SELECT mt_truncate_host("123.23.5.221") --> 123.23.5.221
   **
   **/
  static void mt_truncate_hostFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  
    char *str;
    char *result;
  
    if (sqlite3_value_type(argv[0]) == SQLITE_NULL ){
      // input is null - return null
      sqlite3_result_null(context); 
      return;
    }
  
    str = (char *)sqlite3_value_text(argv[0]);
  
    char *c;
    int numbersOnly = 0;
    int charCount = 0;
    
    for (c = str; *c != '\0'; c++) {
        if (*c == '.' && numbersOnly == 1) {
          break;
        } else if (*c != '.' && numbersOnly == 0 && !isdigit(*c)) {
          numbersOnly = 1;
        }
        charCount++;
    }
  
    result = sqlite3_malloc(charCount+1);
    strncpy(result, str, charCount);
    result[charCount] = '\0';
    sqlite3_result_text(context, (char*)result, -1, SQLITE_TRANSIENT);
  
  }
  
  static int startsWith(char *input, char *checkStr) {
    const int checkStrLength = strlen(checkStr);
    if (strlen(input) >= checkStrLength) { 
      for (int i = 0; i < checkStrLength; i++) {
        if (checkStr[i] != input[i]) {
          return 0;
        }
      }
      return 1;
    }
    return 0;
  }
  
  /**
   ** Converts string to app name
   ** Ex: SELECT mt_nwk_job_to_app("VSS ASR DISK", "bbbb")
   ** Ex: SELECT mt_nwk_job_to_app("<N>index: xyz format", "bbbb")
   ** Ex: SELECT mt_nwk_job_to_app("APPLICATIONS:\\abcdefghijklmnopqrst\123456", "bbbb")
   **/
  static void mt_nwk_job_to_appFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  
    char *jobName;
    char *flags;
    char *app;
    char *result;
  
    if( sqlite3_value_type(argv[0]) == SQLITE_NULL ){
      sqlite3_result_null(context); 
      return;
    }
  
    jobName = sqlite3_value_text(argv[0]);
    flags = sqlite3_value_type(argv[1]) == SQLITE_NULL ? NULL : sqlite3_value_text(argv[1]);
  
    // Extract "index" from "<N>index: xyz format"
    int start = 0;
    int end = strlen(jobName);
    for (int i = 0; i < strlen(jobName); i++) {
        if (jobName[i] == ':' && end > i) {
          end = i;
        } else if (jobName[i] == '>') {
          start = i + 1;
        }
    }
    
    int length = end - start + 1;
    app = sqlite3_malloc(length);
    int i;
    for (i = start; i < end; i++ ) {
        app[i - start] = jobName[i];
    }
    app[i-start] = '\0';
  
    if (startsWith(jobName, "MSSQL") > 0) { 
      result = "MS-SQL";
    } else if (flags != NULL && strchr(flags, 'n') != NULL) { 
      result = "NDMP";
    } else if (strcmp(app, "DB2") == 0) { 
      result = "DB2";
    } else if (strcmp(app, "INFORMIX") == 0) { 
      result = "INFORMIX";
    } else if (strcmp(app, "MSSQL") == 0) { 
      result = "MS-SQL";
    } else if (strcmp(app, "MSEXCH") == 0) { 
      result = "Exchange";
    } else if (strcmp(app, "NOTES") == 0) { 
      result = "Lotus";
    } else if (strcmp(app, "NMEO") == 0) { 
      result = "Oracle";
    } else if (strcmp(app, "Oracle - RMAN") == 0) { 
      result = "Oracle";
    } else if (strcmp(app, "RMAN") == 0) { 
      result = "Oracle";				
    } else if (strcmp(app, "SAP") == 0) { 
      result = "SAP";				
    } else if (strcmp(app, "SYBASE") == 0) { 
      result = "Sybase";				
    } else if (strcmp(app, "backint") == 0) { 
      result = "SAP";				
    } else if (strcmp(app, "index") == 0) { 
      result = "NetWorker Indexes";				
    } else if (strcmp(app, "SYSTEM DB") == 0) { 
      result = "Windows System State";				
    } else if (strcmp(app, "SYSTEM FILES") == 0) { 
      result = "Windows System State";				
    } else if (strcmp(app, "SYSTEM STATE") == 0) { 
      result = "Windows System State";				
    } else if (strcmp(app, "VSS ASR DISK") == 0) { 
      result = "Windows System State";				
    } else if (strcmp(app, "ASR") == 0) { 
      result = "Windows System State";				
    } else if (strcmp(app, "VSS OTHER") == 0) { 
      result = "Windows System State";					
    } else if (strcmp(app, "VSS SYSTEM") == 0) { 
      result = "Windows System State";					
    } else if (strcmp(app, "VSS USER DATA") == 0) { 
      result = "Windows System State";						
    } else if (strcmp(app, "VSS SYSTEM STATE") == 0) { 
      result = "Windows System State";
    } else if (strcmp(app, "VSS SYSTEM BOOT") == 0) { 
      result = "Windows System State";
    } else if (strcmp(app, "VSS SYSTEM SERVICES") == 0) { 
      result = "Windows System State";
    } else if (strcmp(app, "VSS SYSTEM FILESET") == 0) { 
      result = "Windows System State";	
    } else if (startsWith(jobName, "APPLICATIONS:\\\\") > 0) { 
      int start = 15;
      int length = strlen(jobName) - start;
      result = sqlite3_malloc(length + 1);
      memcpy( result, &jobName[start], length);
      result[length] = '\0';
      for (int i = 0; i < length; i++) {
        if (result[i] == '\\') {
          result[i] = '\0';
          break;
        }
      }
    } /*else if (strcmp(app, "APPLICATIONS") == 0) { 
      result = SUBSTRING_INDEX(SUBSTRING_INDEX(SUBSTRING_INDEX(jobName, ":", 2), ":", -1), "\\",2);		
    }*/else {
      result = "Filesystem";
    }
  
    sqlite3_result_text(context, (char*)result, -1, SQLITE_TRANSIENT);
  
    return 0;
  
  }
  
  /*
  ** 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 = 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 = 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 = 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 = 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 = sqlite3_aggregate_context(context, sizeof(*p));
  
    if( 0==(p->m) ){
      p->m = 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 = 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 = 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 = 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 RegisterExtensionFunctions(sqlite3 *db){
    static const struct FuncDef {
       char *zName;
       signed char nArg;
       u8 argType;           /* 0: none.  1: db  2: (-1) */
       u8 eTextRep;          /* 1: UTF-16.  0: UTF-8 */
       u8 needCollSeq;
       void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
    } aFuncs[] = {
      /* math.h */
      { "acos",               1, 0, SQLITE_UTF8,    0, acosFunc  },
      { "asin",               1, 0, SQLITE_UTF8,    0, asinFunc  },
      { "atan",               1, 0, SQLITE_UTF8,    0, atanFunc  },
      { "atn2",               2, 0, SQLITE_UTF8,    0, atn2Func  },
      /* XXX alias */
      { "atan2",              2, 0, SQLITE_UTF8,    0, atn2Func  },
      { "acosh",              1, 0, SQLITE_UTF8,    0, acoshFunc  },
      { "asinh",              1, 0, SQLITE_UTF8,    0, asinhFunc  },
      { "atanh",              1, 0, SQLITE_UTF8,    0, atanhFunc  },
  
      { "difference",         2, 0, SQLITE_UTF8,    0, differenceFunc},
      { "degrees",            1, 0, SQLITE_UTF8,    0, rad2degFunc  },
      { "radians",            1, 0, SQLITE_UTF8,    0, deg2radFunc  },
  
      { "cos",                1, 0, SQLITE_UTF8,    0, cosFunc  },
      { "sin",                1, 0, SQLITE_UTF8,    0, sinFunc },
      { "tan",                1, 0, SQLITE_UTF8,    0, tanFunc },
      { "cot",                1, 0, SQLITE_UTF8,    0, cotFunc },
      { "cosh",               1, 0, SQLITE_UTF8,    0, coshFunc  },
      { "sinh",               1, 0, SQLITE_UTF8,    0, sinhFunc },
      { "tanh",               1, 0, SQLITE_UTF8,    0, tanhFunc },
      { "coth",               1, 0, SQLITE_UTF8,    0, cothFunc },
  
      { "exp",                1, 0, SQLITE_UTF8,    0, expFunc  },
      { "log",                1, 0, SQLITE_UTF8,    0, logFunc  },
      { "log10",              1, 0, SQLITE_UTF8,    0, log10Func  },
      { "power",              2, 0, SQLITE_UTF8,    0, powerFunc  },
      { "sign",               1, 0, SQLITE_UTF8,    0, signFunc },
      { "sqrt",               1, 0, SQLITE_UTF8,    0, sqrtFunc },
      { "square",             1, 0, SQLITE_UTF8,    0, squareFunc },
  
      { "ceil",               1, 0, SQLITE_UTF8,    0, ceilFunc },
      { "floor",              1, 0, SQLITE_UTF8,    0, floorFunc },
  
      { "pi",                 0, 0, SQLITE_UTF8,    1, piFunc },
      { "fromHex",            1, 0, SQLITE_UTF8,    0, fromHexFunc },
  
      /* string */
      { "replicate",          2, 0, SQLITE_UTF8,    0, replicateFunc },
      { "charindex",          2, 0, SQLITE_UTF8,    0, charindexFunc },
      { "charindex",          3, 0, SQLITE_UTF8,    0, charindexFunc },
      { "leftstr",            2, 0, SQLITE_UTF8,    0, leftFunc },
      { "rightstr",           2, 0, SQLITE_UTF8,    0, rightFunc },
  #ifndef HAVE_TRIM
      { "ltrim",              1, 0, SQLITE_UTF8,    0, ltrimFunc },
      { "rtrim",              1, 0, SQLITE_UTF8,    0, rtrimFunc },
      { "trim",               1, 0, SQLITE_UTF8,    0, trimFunc },
      { "replace",            3, 0, SQLITE_UTF8,    0, replaceFunc },
  #endif
      { "reverse",            1, 0, SQLITE_UTF8,    0, reverseFunc },
      { "proper",             1, 0, SQLITE_UTF8,    0, properFunc },
      { "padl",               2, 0, SQLITE_UTF8,    0, padlFunc },
      { "padr",               2, 0, SQLITE_UTF8,    0, padrFunc },
      { "padc",               2, 0, SQLITE_UTF8,    0, padcFunc },
      { "strfilter",          2, 0, SQLITE_UTF8,    0, strfilterFunc },
      { "substring_index",    3, 0, SQLITE_UTF8,    0, substr_indexFunc },
      { "mt_capacity_to_mb",  1, 0, SQLITE_UTF8,    0, mt_capacity_to_mbFunc },
      { "mt_num_days_to_age", 2, 0, SQLITE_UTF8,    0, mt_num_days_to_ageFunc },
      { "mt_truncate_host",   1, 0, SQLITE_UTF8,    0, mt_truncate_hostFunc },
      { "mt_nwk_job_to_app",  2, 0, SQLITE_UTF8,    0, mt_nwk_job_to_appFunc },
      
    };
    /* Aggregate functions */
    static const struct FuncDefAgg {
      char *zName;
      signed char nArg;
      u8 argType;
      u8 needCollSeq;
      void (*xStep)(sqlite3_context*,int,sqlite3_value**);
      void (*xFinalize)(sqlite3_context*);
    } aAggs[] = {
      { "stdev",            1, 0, 0, varianceStep, stdevFinalize  },
      { "variance",         1, 0, 0, varianceStep, varianceFinalize  },
      { "mode",             1, 0, 0, modeStep,     modeFinalize  },
      { "median",           1, 0, 0, modeStep,     medianFinalize  },
      { "lower_quartile",   1, 0, 0, modeStep,     lower_quartileFinalize  },
      { "upper_quartile",   1, 0, 0, modeStep,     upper_quartileFinalize  },
    };
    int i;
  
    for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
      void *pArg = 0;
      switch( aFuncs[i].argType ){
        case 1: pArg = db; break;
        case 2: pArg = (void *)(-1); break;
      }
      //sqlite3CreateFunc
      /* LMH no error checking */
      sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg,
          aFuncs[i].eTextRep, pArg, aFuncs[i].xFunc, 0, 0);
  #if 0
      if( aFuncs[i].needCollSeq ){
        struct FuncDef *pFunc = sqlite3FindFunction(db, aFuncs[i].zName, 
            strlen(aFuncs[i].zName), aFuncs[i].nArg, aFuncs[i].eTextRep, 0);
        if( pFunc && aFuncs[i].needCollSeq ){
          pFunc->needCollSeq = 1;
        }
      }
  #endif
    }
  
    for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){
      void *pArg = 0;
      switch( aAggs[i].argType ){
        case 1: pArg = db; break;
        case 2: pArg = (void *)(-1); break;
      }
      //sqlite3CreateFunc
      /* LMH no error checking */
      sqlite3_create_function(db, aAggs[i].zName, aAggs[i].nArg, SQLITE_UTF8, 
          pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize);
  #if 0
      if( aAggs[i].needCollSeq ){
        struct FuncDefAgg *pFunc = sqlite3FindFunction( db, aAggs[i].zName,
            strlen(aAggs[i].zName), aAggs[i].nArg, SQLITE_UTF8, 0);
        if( pFunc && aAggs[i].needCollSeq ){
          pFunc->needCollSeq = 1;
        }
      }
  #endif
    }
    return 0;
  }
  
  #ifdef _WIN32
  __declspec(dllexport)
  #endif
  
  #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;
  
    return r;
  }
  
  void* xcalloc(size_t nmemb, size_t size, char* s){
    void* ret = calloc(nmemb, size);
    return ret;
  }
  
  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 => %lld\n", ee,c);
  }
  
  