/*

** 2002 February 23

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

*************************************************************************

** This file contains the C functions that implement various SQL

** functions of SQLite.

**

** There is only one exported symbol in this file - the function

** sqliteRegisterBuildinFunctions() found at the bottom of the file.

** All other code has file scope.

**

** $Id: func.c,v 1.196 2008/07/28 19:34:53 drh Exp $

*/

#include "sqliteInt.h"

#include <ctype.h>

#include <stdlib.h>

#include <assert.h>

#include "vdbeInt.h"

/*

** Return the collating function associated with a function.

*/

static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){

return context->pColl;

}

/*

** Implementation of the non-aggregate min() and max() functions

*/

static void minmaxFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

int i;

int mask; /* 0 for min() or 0xffffffff for max() */

int iBest;

CollSeq *pColl;

if( argc==0 ) return;

mask = sqlite3_user_data(context)==0 ? 0 : -1;

pColl = sqlite3GetFuncCollSeq(context);

assert( pColl );

assert( mask==-1 || mask==0 );

iBest = 0;

if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;

for(i=1; i<argc; i++){

if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;

if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){

iBest = i;

}

}

sqlite3_result_value(context, argv[iBest]);

}

/*

** Return the type of the argument.

*/

static void typeofFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

const char *z = 0;

switch( sqlite3_value_type(argv[0]) ){

case SQLITE_NULL: z = "null"; break;

case SQLITE_INTEGER: z = "integer"; break;

case SQLITE_TEXT: z = "text"; break;

case SQLITE_FLOAT: z = "real"; break;

case SQLITE_BLOB: z = "blob"; break;

}

sqlite3_result_text(context, z, -1, SQLITE_STATIC);

}

/*

** Implementation of the length() function

*/

static void lengthFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

int len;

assert( argc==1 );

switch( sqlite3_value_type(argv[0]) ){

case SQLITE_BLOB:

case SQLITE_INTEGER:

case SQLITE_FLOAT: {

sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));

break;

}

case SQLITE_TEXT: {

const unsigned char *z = sqlite3_value_text(argv[0]);

if( z==0 ) return;

len = 0;

while( *z ){

len++;

SQLITE_SKIP_UTF8(z);

}

sqlite3_result_int(context, len);

break;

}

default: {

sqlite3_result_null(context);

break;

}

}

}

/*

** Implementation of the abs() function

*/

static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){

assert( argc==1 );

switch( sqlite3_value_type(argv[0]) ){

case SQLITE_INTEGER: {

i64 iVal = sqlite3_value_int64(argv[0]);

if( iVal<0 ){

if( (iVal<<1)==0 ){

sqlite3_result_error(context, "integer overflow", -1);

return;

}

iVal = -iVal;

}

sqlite3_result_int64(context, iVal);

break;

}

case SQLITE_NULL: {

sqlite3_result_null(context);

break;

}

default: {

double rVal = sqlite3_value_double(argv[0]);

if( rVal<0 ) rVal = -rVal;

sqlite3_result_double(context, rVal);

break;

}

}

}

/*

** Implementation of the substr() function.

**

** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.

** p1 is 1-indexed. So substr(x,1,1) returns the first character

** of x. If x is text, then we actually count UTF-8 characters.

** If x is a blob, then we count bytes.

**

** If p1 is negative, then we begin abs(p1) from the end of x[].

*/

static void substrFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

const unsigned char *z;

const unsigned char *z2;

int len;

int p0type;

i64 p1, p2;

assert( argc==3 || argc==2 );

p0type = sqlite3_value_type(argv[0]);

if( p0type==SQLITE_BLOB ){

len = sqlite3_value_bytes(argv[0]);

z = sqlite3_value_blob(argv[0]);

if( z==0 ) return;

assert( len==sqlite3_value_bytes(argv[0]) );

}else{

z = sqlite3_value_text(argv[0]);

if( z==0 ) return;

len = 0;

for(z2=z; *z2; len++){

SQLITE_SKIP_UTF8(z2);

}

}

p1 = sqlite3_value_int(argv[1]);

if( argc==3 ){

p2 = sqlite3_value_int(argv[2]);

}else{

p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];

}

if( p1<0 ){

p1 += len;

if( p1<0 ){

p2 += p1;

p1 = 0;

}

}else if( p1>0 ){

p1--;

}

if( p1+p2>len ){

p2 = len-p1;

}

if( p0type!=SQLITE_BLOB ){

while( *z && p1 ){

SQLITE_SKIP_UTF8(z);

p1--;

}

for(z2=z; *z2 && p2; p2--){

SQLITE_SKIP_UTF8(z2);

}

sqlite3_result_text(context, (char*)z, z2-z, SQLITE_TRANSIENT);

}else{

if( p2<0 ) p2 = 0;

sqlite3_result_blob(context, (char*)&z[p1], p2, SQLITE_TRANSIENT);

}

}

/*

** Implementation of the round() function

*/

static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){

int n = 0;

double r;

char zBuf[500]; /* larger than the %f representation of the largest double */

assert( argc==1 || argc==2 );

if( argc==2 ){

if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;

n = sqlite3_value_int(argv[1]);

if( n>30 ) n = 30;

if( n<0 ) n = 0;

}

if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;

r = sqlite3_value_double(argv[0]);

sqlite3_snprintf(sizeof(zBuf),zBuf,"%.*f",n,r);

sqlite3AtoF(zBuf, &r);

sqlite3_result_double(context, r);

}

/*

** Allocate nByte bytes of space using sqlite3_malloc(). If the

** allocation fails, call sqlite3_result_error_nomem() to notify

** the database handle that malloc() has failed.

*/

static void *contextMalloc(sqlite3_context *context, i64 nByte){

char *z;

if( nByte>sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH] ){

sqlite3_result_error_toobig(context);

z = 0;

}else{

z = sqlite3Malloc(nByte);

if( !z && nByte>0 ){

sqlite3_result_error_nomem(context);

}

}

return z;

}

/*

** Implementation of the upper() and lower() SQL functions.

*/

static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){

char *z1;

const char *z2;

int i, n;

if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;

z2 = (char*)sqlite3_value_text(argv[0]);

n = sqlite3_value_bytes(argv[0]);

/* Verify that the call to _bytes() does not invalidate the _text() pointer */

assert( z2==(char*)sqlite3_value_text(argv[0]) );

if( z2 ){

z1 = contextMalloc(context, ((i64)n)+1);

if( z1 ){

memcpy(z1, z2, n+1);

for(i=0; z1[i]; i++){

z1[i] = toupper(z1[i]);

}

sqlite3_result_text(context, z1, -1, sqlite3_free);

}

}

}

static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){

char *z1;

const char *z2;

int i, n;

if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;

z2 = (char*)sqlite3_value_text(argv[0]);

n = sqlite3_value_bytes(argv[0]);

/* Verify that the call to _bytes() does not invalidate the _text() pointer */

assert( z2==(char*)sqlite3_value_text(argv[0]) );

if( z2 ){

z1 = contextMalloc(context, ((i64)n)+1);

if( z1 ){

memcpy(z1, z2, n+1);

for(i=0; z1[i]; i++){

z1[i] = tolower(z1[i]);

}

sqlite3_result_text(context, z1, -1, sqlite3_free);

}

}

}

/*

** Implementation of the IFNULL(), NVL(), and COALESCE() functions.

** All three do the same thing. They return the first non-NULL

** argument.

*/

static void ifnullFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

int i;

for(i=0; i<argc; i++){

if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){

sqlite3_result_value(context, argv[i]);

break;

}

}

}

/*

** Implementation of random(). Return a random integer.

*/

static void randomFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

sqlite_int64 r;

sqlite3_randomness(sizeof(r), &r);

if( (r<<1)==0 ) r = 0; /* Prevent 0x8000.... as the result so that we */

/* can always do abs() of the result */

sqlite3_result_int64(context, r);

}

/*

** Implementation of randomblob(N). Return a random blob

** that is N bytes long.

*/

static void randomBlob(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

int n;

unsigned char *p;

assert( argc==1 );

n = sqlite3_value_int(argv[0]);

if( n<1 ){

n = 1;

}

p = contextMalloc(context, n);

if( p ){

sqlite3_randomness(n, p);

sqlite3_result_blob(context, (char*)p, n, sqlite3_free);

}

}

/*

** Implementation of the last_insert_rowid() SQL function. The return

** value is the same as the sqlite3_last_insert_rowid() API function.

*/

static void last_insert_rowid(

sqlite3_context *context,

int arg,

sqlite3_value **argv

){

sqlite3 *db = sqlite3_context_db_handle(context);

sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));

}

/*

** Implementation of the changes() SQL function. The return value is the

** same as the sqlite3_changes() API function.

*/

static void changes(

sqlite3_context *context,

int arg,

sqlite3_value **argv

){

sqlite3 *db = sqlite3_context_db_handle(context);

sqlite3_result_int(context, sqlite3_changes(db));

}

/*

** Implementation of the total_changes() SQL function. The return value is

** the same as the sqlite3_total_changes() API function.

*/

static void total_changes(

sqlite3_context *context,

int arg,

sqlite3_value **argv

){

sqlite3 *db = sqlite3_context_db_handle(context);

sqlite3_result_int(context, sqlite3_total_changes(db));

}

/*

** A structure defining how to do GLOB-style comparisons.

*/

struct compareInfo {

u8 matchAll;

u8 matchOne;

u8 matchSet;

u8 noCase;

};

/*

** For LIKE and GLOB matching on EBCDIC machines, assume that every

** character is exactly one byte in size. Also, all characters are

** able to participate in upper-case-to-lower-case mappings in EBCDIC

** whereas only characters less than 0x80 do in ASCII.

*/

#if defined(SQLITE_EBCDIC)

# define sqlite3Utf8Read(A,B,C) (*(A++))

# define GlogUpperToLower(A) A = sqlite3UpperToLower[A]

#else

# define GlogUpperToLower(A) if( A<0x80 ){ A = sqlite3UpperToLower[A]; }

#endif

static const struct compareInfo globInfo = { '*', '?', '[', 0 };

/* The correct SQL-92 behavior is for the LIKE operator to ignore

** case. Thus 'a' LIKE 'A' would be true. */

static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 };

/* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator

** is case sensitive causing 'a' LIKE 'A' to be false */

static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 };

/*

** Compare two UTF-8 strings for equality where the first string can

** potentially be a "glob" expression. Return true (1) if they

** are the same and false (0) if they are different.

**

** Globbing rules:

**

** '*' Matches any sequence of zero or more characters.

**

** '?' Matches exactly one character.

**

** [...] Matches one character from the enclosed list of

** characters.

**

** [^...] Matches one character not in the enclosed list.

**

** With the [...] and [^...] matching, a ']' character can be included

** in the list by making it the first character after '[' or '^'. A

** range of characters can be specified using '-'. Example:

** "[a-z]" matches any single lower-case letter. To match a '-', make

** it the last character in the list.

**

** This routine is usually quick, but can be N**2 in the worst case.

**

** Hints: to match '*' or '?', put them in "[]". Like this:

**

** abc[*]xyz Matches "abc*xyz" only

*/

static int patternCompare(

const u8 *zPattern, /* The glob pattern */

const u8 *zString, /* The string to compare against the glob */

const struct compareInfo *pInfo, /* Information about how to do the compare */

const int esc /* The escape character */

){

int c, c2;

int invert;

int seen;

u8 matchOne = pInfo->matchOne;

u8 matchAll = pInfo->matchAll;

u8 matchSet = pInfo->matchSet;

u8 noCase = pInfo->noCase;

int prevEscape = 0; /* True if the previous character was 'escape' */

while( (c = sqlite3Utf8Read(zPattern,0,&zPattern))!=0 ){

if( !prevEscape && c==matchAll ){

while( (c=sqlite3Utf8Read(zPattern,0,&zPattern)) == matchAll

|| c == matchOne ){

if( c==matchOne && sqlite3Utf8Read(zString, 0, &zString)==0 ){

return 0;

}

}

if( c==0 ){

return 1;

}else if( c==esc ){

c = sqlite3Utf8Read(zPattern, 0, &zPattern);

if( c==0 ){

return 0;

}

}else if( c==matchSet ){

assert( esc==0 ); /* This is GLOB, not LIKE */

assert( matchSet<0x80 ); /* '[' is a single-byte character */

while( *zString && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){

SQLITE_SKIP_UTF8(zString);

}

return *zString!=0;

}

while( (c2 = sqlite3Utf8Read(zString,0,&zString))!=0 ){

if( noCase ){

GlogUpperToLower(c2);

GlogUpperToLower(c);

while( c2 != 0 && c2 != c ){

c2 = sqlite3Utf8Read(zString, 0, &zString);

GlogUpperToLower(c2);

}

}else{

while( c2 != 0 && c2 != c ){

c2 = sqlite3Utf8Read(zString, 0, &zString);

}

}

if( c2==0 ) return 0;

if( patternCompare(zPattern,zString,pInfo,esc) ) return 1;

}

return 0;

}else if( !prevEscape && c==matchOne ){

if( sqlite3Utf8Read(zString, 0, &zString)==0 ){

return 0;

}

}else if( c==matchSet ){

int prior_c = 0;

assert( esc==0 ); /* This only occurs for GLOB, not LIKE */

seen = 0;

invert = 0;

c = sqlite3Utf8Read(zString, 0, &zString);

if( c==0 ) return 0;

c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);

if( c2=='^' ){

invert = 1;

c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);

}

if( c2==']' ){

if( c==']' ) seen = 1;

c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);

}

while( c2 && c2!=']' ){

if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){

c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);

if( c>=prior_c && c<=c2 ) seen = 1;

prior_c = 0;

}else{

if( c==c2 ){

seen = 1;

}

prior_c = c2;

}

c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);

}

if( c2==0 || (seen ^ invert)==0 ){

return 0;

}

}else if( esc==c && !prevEscape ){

prevEscape = 1;

}else{

c2 = sqlite3Utf8Read(zString, 0, &zString);

if( noCase ){

GlogUpperToLower(c);

GlogUpperToLower(c2);

}

if( c!=c2 ){

return 0;

}

prevEscape = 0;

}

}

return *zString==0;

}

/*

** Count the number of times that the LIKE operator (or GLOB which is

** just a variation of LIKE) gets called. This is used for testing

** only.

*/

#ifdef SQLITE_TEST

int sqlite3_like_count = 0;

#endif

/*

** Implementation of the like() SQL function. This function implements

** the build-in LIKE operator. The first argument to the function is the

** pattern and the second argument is the string. So, the SQL statements:

**

** A LIKE B

**

** is implemented as like(B,A).

**

** This same function (with a different compareInfo structure) computes

** the GLOB operator.

*/

static void likeFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

const unsigned char *zA, *zB;

int escape = 0;

sqlite3 *db = sqlite3_context_db_handle(context);

zB = sqlite3_value_text(argv[0]);

zA = sqlite3_value_text(argv[1]);

/* Limit the length of the LIKE or GLOB pattern to avoid problems

** of deep recursion and N*N behavior in patternCompare().

*/

if( sqlite3_value_bytes(argv[0]) >

db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){

sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);

return;

}

assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */

if( argc==3 ){

/* The escape character string must consist of a single UTF-8 character.

** Otherwise, return an error.

*/

const unsigned char *zEsc = sqlite3_value_text(argv[2]);

if( zEsc==0 ) return;

if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){

sqlite3_result_error(context,

"ESCAPE expression must be a single character", -1);

return;

}

escape = sqlite3Utf8Read(zEsc, 0, &zEsc);

}

if( zA && zB ){

struct compareInfo *pInfo = sqlite3_user_data(context);

#ifdef SQLITE_TEST

sqlite3_like_count++;

#endif

sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape));

}

}

/*

** Implementation of the NULLIF(x,y) function. The result is the first

** argument if the arguments are different. The result is NULL if the

** arguments are equal to each other.

*/

static void nullifFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

CollSeq *pColl = sqlite3GetFuncCollSeq(context);

if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){

sqlite3_result_value(context, argv[0]);

}

}

/*

** Implementation of the VERSION(*) function. The result is the version

** of the SQLite library that is running.

*/

static void versionFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

sqlite3_result_text(context, sqlite3_version, -1, SQLITE_STATIC);

}

/* Array for converting from half-bytes (nybbles) into ASCII hex

** digits. */

static const char hexdigits[] = {

'0', '1', '2', '3', '4', '5', '6', '7',

'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'

};

/*

** EXPERIMENTAL - This is not an official function. The interface may

** change. This function may disappear. Do not write code that depends

** on this function.

**

** Implementation of the QUOTE() function. This function takes a single

** argument. If the argument is numeric, the return value is the same as

** the argument. If the argument is NULL, the return value is the string

** "NULL". Otherwise, the argument is enclosed in single quotes with

** single-quote escapes.

*/

static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){

if( argc<1 ) return;

switch( sqlite3_value_type(argv[0]) ){

case SQLITE_NULL: {

sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);

break;

}

case SQLITE_INTEGER:

case SQLITE_FLOAT: {

sqlite3_result_value(context, argv[0]);

break;

}

case SQLITE_BLOB: {

char *zText = 0;

char const *zBlob = sqlite3_value_blob(argv[0]);

int nBlob = sqlite3_value_bytes(argv[0]);

assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */

zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4);

if( zText ){

int i;

for(i=0; i<nBlob; i++){

zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];

zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];

}

zText[(nBlob*2)+2] = '\'';

zText[(nBlob*2)+3] = '\0';

zText[0] = 'X';

zText[1] = '\'';

sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);

sqlite3_free(zText);

}

break;

}

case SQLITE_TEXT: {

int i,j;

u64 n;

const unsigned char *zArg = sqlite3_value_text(argv[0]);

char *z;

if( zArg==0 ) return;

for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }

z = contextMalloc(context, ((i64)i)+((i64)n)+3);

if( z ){

z[0] = '\'';

for(i=0, j=1; zArg[i]; i++){

z[j++] = zArg[i];

if( zArg[i]=='\'' ){

z[j++] = '\'';

}

}

z[j++] = '\'';

z[j] = 0;

sqlite3_result_text(context, z, j, sqlite3_free);

}

}

}

}

/*

** The hex() function. Interpret the argument as a blob. Return

** a hexadecimal rendering as text.

*/

static void hexFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

int i, n;

const unsigned char *pBlob;

char *zHex, *z;

assert( argc==1 );

pBlob = sqlite3_value_blob(argv[0]);

n = sqlite3_value_bytes(argv[0]);

assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */

z = zHex = contextMalloc(context, ((i64)n)*2 + 1);

if( zHex ){

for(i=0; i<n; i++, pBlob++){

unsigned char c = *pBlob;

*(z++) = hexdigits[(c>>4)&0xf];

*(z++) = hexdigits[c&0xf];

}

*z = 0;

sqlite3_result_text(context, zHex, n*2, sqlite3_free);

}

}

/*

** The zeroblob(N) function returns a zero-filled blob of size N bytes.

*/

static void zeroblobFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

i64 n;

assert( argc==1 );

n = sqlite3_value_int64(argv[0]);

if( n>SQLITE_MAX_LENGTH ){

sqlite3_result_error_toobig(context);

}else{

sqlite3_result_zeroblob(context, n);

}

}

/*

** The replace() function. Three arguments are all strings: call

** them A, B, and C. The result is also a string which is derived

** from A by replacing every occurance of B with C. The match

** must be exact. Collating sequences are not used.

*/

static void replaceFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

const unsigned char *zStr; /* The input string A */

const unsigned char *zPattern; /* The pattern string B */

const unsigned char *zRep; /* The replacement string C */

unsigned char *zOut; /* The output */

int nStr; /* Size of zStr */

int nPattern; /* Size of zPattern */

int nRep; /* Size of zRep */

i64 nOut; /* Maximum size of zOut */

int loopLimit; /* Last zStr[] that might match zPattern[] */

int i, j; /* Loop counters */

assert( argc==3 );

zStr = sqlite3_value_text(argv[0]);

if( zStr==0 ) return;

nStr = sqlite3_value_bytes(argv[0]);

assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */

zPattern = sqlite3_value_text(argv[1]);

if( zPattern==0 || zPattern[0]==0 ) return;

nPattern = sqlite3_value_bytes(argv[1]);

assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */

zRep = sqlite3_value_text(argv[2]);

if( zRep==0 ) return;

nRep = sqlite3_value_bytes(argv[2]);

assert( zRep==sqlite3_value_text(argv[2]) );

nOut = nStr + 1;

assert( nOut<SQLITE_MAX_LENGTH );

zOut = contextMalloc(context, (i64)nOut);

if( zOut==0 ){

return;

}

loopLimit = nStr - nPattern;

for(i=j=0; i<=loopLimit; i++){

if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){

zOut[j++] = zStr[i];

}else{

u8 *zOld;

sqlite3 *db = sqlite3_context_db_handle(context);

nOut += nRep - nPattern;

if( nOut>=db->aLimit[SQLITE_LIMIT_LENGTH] ){

sqlite3_result_error_toobig(context);

sqlite3DbFree(db, zOut);

return;

}

zOld = zOut;

zOut = sqlite3_realloc(zOut, (int)nOut);

if( zOut==0 ){

sqlite3_result_error_nomem(context);

sqlite3DbFree(db, zOld);

return;

}

memcpy(&zOut[j], zRep, nRep);

j += nRep;

i += nPattern-1;

}

}

assert( j+nStr-i+1==nOut );

memcpy(&zOut[j], &zStr[i], nStr-i);

j += nStr - i;

assert( j<=nOut );

zOut[j] = 0;

sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);

}

/*

** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.

** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.

*/

static void trimFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

const unsigned char *zIn; /* Input string */

const unsigned char *zCharSet; /* Set of characters to trim */

int nIn; /* Number of bytes in input */

int flags; /* 1: trimleft 2: trimright 3: trim */

int i; /* Loop counter */

unsigned char *aLen; /* Length of each character in zCharSet */

unsigned char **azChar; /* Individual characters in zCharSet */

int nChar; /* Number of characters in zCharSet */

if( sqlite3_value_type(argv[0])==SQLITE_NULL ){

return;

}

zIn = sqlite3_value_text(argv[0]);

if( zIn==0 ) return;

nIn = sqlite3_value_bytes(argv[0]);

assert( zIn==sqlite3_value_text(argv[0]) );

if( argc==1 ){

static const unsigned char lenOne[] = { 1 };

static const unsigned char *azOne[] = { (u8*)" " };

nChar = 1;

aLen = (u8*)lenOne;

azChar = (unsigned char **)azOne;

zCharSet = 0;

}else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){

return;

}else{

const unsigned char *z;

for(z=zCharSet, nChar=0; *z; nChar++){

SQLITE_SKIP_UTF8(z);

}

if( nChar>0 ){

azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));

if( azChar==0 ){

return;

}

aLen = (unsigned char*)&azChar[nChar];

for(z=zCharSet, nChar=0; *z; nChar++){

azChar[nChar] = (unsigned char *)z;

SQLITE_SKIP_UTF8(z);

aLen[nChar] = z - azChar[nChar];

}

}

}

if( nChar>0 ){

flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));

if( flags & 1 ){

while( nIn>0 ){

int len;

for(i=0; i<nChar; i++){

len = aLen[i];

if( memcmp(zIn, azChar[i], len)==0 ) break;

}

if( i>=nChar ) break;

zIn += len;

nIn -= len;

}

}

if( flags & 2 ){

while( nIn>0 ){

int len;

for(i=0; i<nChar; i++){

len = aLen[i];

if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;

}

if( i>=nChar ) break;

nIn -= len;

}

}

if( zCharSet ){

sqlite3_free(azChar);

}

}

sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);

}

#ifdef SQLITE_SOUNDEX

/*

** Compute the soundex encoding of a word.

*/

static void soundexFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

char zResult[8];

const u8 *zIn;

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,

};

assert( argc==1 );

zIn = (u8*)sqlite3_value_text(argv[0]);

if( zIn==0 ) zIn = (u8*)"";

for(i=0; zIn[i] && !isalpha(zIn[i]); i++){}

if( zIn[i] ){

u8 prevcode = iCode[zIn[i]&0x7f];

zResult[0] = toupper(zIn[i]);

for(j=1; j<4 && zIn[i]; i++){

int code = iCode[zIn[i]&0x7f];

if( code>0 ){

if( code!=prevcode ){

prevcode = code;

zResult[j++] = code + '0';

}

}else{

prevcode = 0;

}

}

while( j<4 ){

zResult[j++] = '0';

}

zResult[j] = 0;

sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);

}else{

sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);

}

}

#endif

#ifndef SQLITE_OMIT_LOAD_EXTENSION

/*

** A function that loads a shared-library extension then returns NULL.

*/

static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){

const char *zFile = (const char *)sqlite3_value_text(argv[0]);

const char *zProc;

sqlite3 *db = sqlite3_context_db_handle(context);