/*

** 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-language implementations for many of the SQL

** functions of SQLite. (Some function, and in particular the date and

** time functions, are implemented separately.)

*/

#include "sqliteInt.h"

#include <stdlib.h>

#include <assert.h>

#include "vdbeInt.h"

/*

** Return the collating function associated with a function.

*/

static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){

VdbeOp *pOp;

assert( context->pVdbe!=0 );

pOp = &context->pVdbe->aOp[context->iOp-1];

assert( pOp->opcode==OP_CollSeq );

assert( pOp->p4type==P4_COLLSEQ );

return pOp->p4.pColl;

}

/*

** Indicate that the accumulator load should be skipped on this

** iteration of the aggregate loop.

*/

static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){

assert( context->isError<=0 );

context->isError = -1;

context->skipFlag = 1;

}

/*

** 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;

assert( argc>1 );

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 ){

testcase( mask==0 );

iBest = i;

}

}

sqlite3_result_value(context, argv[iBest]);

}

/*

** Return the type of the argument.

*/

static void typeofFunc(

sqlite3_context *context,

int NotUsed,

sqlite3_value **argv

){

static const char *azType[] = { "integer", "real", "text", "blob", "null" };

int i = sqlite3_value_type(argv[0]) - 1;

UNUSED_PARAMETER(NotUsed);

assert( i>=0 && i<ArraySize(azType) );

assert( SQLITE_INTEGER==1 );

assert( SQLITE_FLOAT==2 );

assert( SQLITE_TEXT==3 );

assert( SQLITE_BLOB==4 );

assert( SQLITE_NULL==5 );

/* EVIDENCE-OF: R-01470-60482 The sqlite3_value_type(V) interface returns

** the datatype code for the initial datatype of the sqlite3_value object

** V. The returned value is one of SQLITE_INTEGER, SQLITE_FLOAT,

** SQLITE_TEXT, SQLITE_BLOB, or SQLITE_NULL. */

sqlite3_result_text(context, azType[i], -1, SQLITE_STATIC);

}

/*

** Implementation of the length() function

*/

static void lengthFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

assert( argc==1 );

UNUSED_PARAMETER(argc);

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]);

const unsigned char *z0;

unsigned char c;

if( z==0 ) return;

z0 = z;

while( (c = *z)!=0 ){

z++;

if( c>=0xc0 ){

while( (*z & 0xc0)==0x80 ){ z++; z0++; }

}

}

sqlite3_result_int(context, (int)(z-z0));

break;

}

default: {

sqlite3_result_null(context);

break;

}

}

}

/*

** Implementation of the abs() function.

**

** IMP: R-23979-26855 The abs(X) function returns the absolute value of

** the numeric argument X.

*/

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

assert( argc==1 );

UNUSED_PARAMETER(argc);

switch( sqlite3_value_type(argv[0]) ){

case SQLITE_INTEGER: {

i64 iVal = sqlite3_value_int64(argv[0]);

if( iVal<0 ){

if( iVal==SMALLEST_INT64 ){

/* IMP: R-31676-45509 If X is the integer -9223372036854775808

** then abs(X) throws an integer overflow error since there is no

** equivalent positive 64-bit two complement value. */

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

return;

}

iVal = -iVal;

}

sqlite3_result_int64(context, iVal);

break;

}

case SQLITE_NULL: {

/* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */

sqlite3_result_null(context);

break;

}

default: {

/* Because sqlite3_value_double() returns 0.0 if the argument is not

** something that can be converted into a number, we have:

** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob

** that cannot be converted to a numeric value.

*/

double rVal = sqlite3_value_double(argv[0]);

if( rVal<0 ) rVal = -rVal;

sqlite3_result_double(context, rVal);

break;

}

}

}

/*

** Implementation of the instr() function.

**

** instr(haystack,needle) finds the first occurrence of needle

** in haystack and returns the number of previous characters plus 1,

** or 0 if needle does not occur within haystack.

**

** If both haystack and needle are BLOBs, then the result is one more than

** the number of bytes in haystack prior to the first occurrence of needle,

** or 0 if needle never occurs in haystack.

*/

static void instrFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

const unsigned char *zHaystack;

const unsigned char *zNeedle;

int nHaystack;

int nNeedle;

int typeHaystack, typeNeedle;

int N = 1;

int isText;

UNUSED_PARAMETER(argc);

typeHaystack = sqlite3_value_type(argv[0]);

typeNeedle = sqlite3_value_type(argv[1]);

if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return;

nHaystack = sqlite3_value_bytes(argv[0]);

nNeedle = sqlite3_value_bytes(argv[1]);

if( nNeedle>0 ){

if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){

zHaystack = sqlite3_value_blob(argv[0]);

zNeedle = sqlite3_value_blob(argv[1]);

isText = 0;

}else{

zHaystack = sqlite3_value_text(argv[0]);

zNeedle = sqlite3_value_text(argv[1]);

isText = 1;

}

if( zNeedle==0 || (nHaystack && zHaystack==0) ) return;

while( nNeedle<=nHaystack && memcmp(zHaystack, zNeedle, nNeedle)!=0 ){

N++;

do{

nHaystack--;

zHaystack++;

}while( isText && (zHaystack[0]&0xc0)==0x80 );

}

if( nNeedle>nHaystack ) N = 0;

}

sqlite3_result_int(context, N);

}

/*

** Implementation of the printf() function.

*/

static void printfFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

PrintfArguments x;

StrAccum str;

const char *zFormat;

int n;

sqlite3 *db = sqlite3_context_db_handle(context);

if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){

x.nArg = argc-1;

x.nUsed = 0;

x.apArg = argv+1;

sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);

str.printfFlags = SQLITE_PRINTF_SQLFUNC;

sqlite3XPrintf(&str, zFormat, &x);

n = str.nChar;

sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,

SQLITE_DYNAMIC);

}

}

/*

** 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[].

**

** If p2 is negative, return the p2 characters preceding p1.

*/

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;

int negP2 = 0;

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

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

|| (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL)

){

return;

}

p0type = sqlite3_value_type(argv[0]);

p1 = sqlite3_value_int(argv[1]);

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;

if( p1<0 ){

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

SQLITE_SKIP_UTF8(z2);

}

}

}

#ifdef SQLITE_SUBSTR_COMPATIBILITY

/* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as

** as substr(X,1,N) - it returns the first N characters of X. This

** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]

** from 2009-02-02 for compatibility of applications that exploited the

** old buggy behavior. */

if( p1==0 ) p1 = 1; /* <rdar://problem/6778339> */

#endif

if( argc==3 ){

p2 = sqlite3_value_int(argv[2]);

if( p2<0 ){

p2 = -p2;

negP2 = 1;

}

}else{

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

}

if( p1<0 ){

p1 += len;

if( p1<0 ){

p2 += p1;

if( p2<0 ) p2 = 0;

p1 = 0;

}

}else if( p1>0 ){

p1--;

}else if( p2>0 ){

p2--;

}

if( negP2 ){

p1 -= p2;

if( p1<0 ){

p2 += p1;

p1 = 0;

}

}

assert( p1>=0 && p2>=0 );

if( p0type!=SQLITE_BLOB ){

while( *z && p1 ){

SQLITE_SKIP_UTF8(z);

p1--;

}

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

SQLITE_SKIP_UTF8(z2);

}

sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT,

SQLITE_UTF8);

}else{

if( p1+p2>len ){

p2 = len-p1;

if( p2<0 ) p2 = 0;

}

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

}

}

/*

** Implementation of the round() function

*/

#ifndef SQLITE_OMIT_FLOATING_POINT

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

int n = 0;

double r;

char *zBuf;

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

if( argc==2 ){

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

n = sqlite3_value_int(argv[1]);

if( n>30 ) n = 30;

if( n<0 ) n = 0;

}

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

r = sqlite3_value_double(argv[0]);

/* If Y==0 and X will fit in a 64-bit int,

** handle the rounding directly,

** otherwise use printf.

*/

if( n==0 && r>=0 && r<LARGEST_INT64-1 ){

r = (double)((sqlite_int64)(r+0.5));

}else if( n==0 && r<0 && (-r)<LARGEST_INT64-1 ){

r = -(double)((sqlite_int64)((-r)+0.5));

}else{

zBuf = sqlite3_mprintf("%.*f",n,r);

if( zBuf==0 ){

sqlite3_result_error_nomem(context);

return;

}

sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);

sqlite3_free(zBuf);

}

sqlite3_result_double(context, r);

}

#endif

/*

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

** allocation fails, call sqlite3_result_error_nomem() to notify

** the database handle that malloc() has failed and return NULL.

** If nByte is larger than the maximum string or blob length, then

** raise an SQLITE_TOOBIG exception and return NULL.

*/

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

char *z;

sqlite3 *db = sqlite3_context_db_handle(context);

assert( nByte>0 );

testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );

testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );

if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){

sqlite3_result_error_toobig(context);

z = 0;

}else{

z = sqlite3Malloc(nByte);

if( !z ){

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;

UNUSED_PARAMETER(argc);

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

n = sqlite3_value_bytes(argv[0]);

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

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

if( z2 ){

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

if( z1 ){

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

z1[i] = (char)sqlite3Toupper(z2[i]);

}

sqlite3_result_text(context, z1, n, sqlite3_free);

}

}

}

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

char *z1;

const char *z2;

int i, n;

UNUSED_PARAMETER(argc);

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

n = sqlite3_value_bytes(argv[0]);

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

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

if( z2 ){

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

if( z1 ){

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

z1[i] = sqlite3Tolower(z2[i]);

}

sqlite3_result_text(context, z1, n, sqlite3_free);

}

}

}

/*

** Some functions like COALESCE() and IFNULL() and UNLIKELY() are implemented

** as VDBE code so that unused argument values do not have to be computed.

** However, we still need some kind of function implementation for this

** routines in the function table. The noopFunc macro provides this.

** noopFunc will never be called so it doesn't matter what the implementation

** is. We might as well use the "version()" function as a substitute.

*/

#define noopFunc versionFunc /* Substitute function - never called */

/*

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

*/

static void randomFunc(

sqlite3_context *context,

int NotUsed,

sqlite3_value **NotUsed2

){

sqlite_int64 r;

UNUSED_PARAMETER2(NotUsed, NotUsed2);

sqlite3_randomness(sizeof(r), &r);

if( r<0 ){

/* We need to prevent a random number of 0x8000000000000000

** (or -9223372036854775808) since when you do abs() of that

** number of you get the same value back again. To do this

** in a way that is testable, mask the sign bit off of negative

** values, resulting in a positive value. Then take the

** 2s complement of that positive value. The end result can

** therefore be no less than -9223372036854775807.

*/

r = -(r & LARGEST_INT64);

}

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 );

UNUSED_PARAMETER(argc);

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 NotUsed,

sqlite3_value **NotUsed2

){

sqlite3 *db = sqlite3_context_db_handle(context);

UNUSED_PARAMETER2(NotUsed, NotUsed2);

/* IMP: R-51513-12026 The last_insert_rowid() SQL function is a

** wrapper around the sqlite3_last_insert_rowid() C/C++ interface

** function. */

sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));

}

/*

** Implementation of the changes() SQL function.

**

** IMP: R-62073-11209 The changes() SQL function is a wrapper

** around the sqlite3_changes() C/C++ function and hence follows the same

** rules for counting changes.

*/

static void changes(

sqlite3_context *context,

int NotUsed,

sqlite3_value **NotUsed2

){

sqlite3 *db = sqlite3_context_db_handle(context);

UNUSED_PARAMETER2(NotUsed, NotUsed2);

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 NotUsed,

sqlite3_value **NotUsed2

){

sqlite3 *db = sqlite3_context_db_handle(context);

UNUSED_PARAMETER2(NotUsed, NotUsed2);

/* IMP: R-52756-41993 This function is a wrapper around the

** sqlite3_total_changes() C/C++ interface. */

sqlite3_result_int(context, sqlite3_total_changes(db));

}

/*

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

*/

struct compareInfo {

u8 matchAll; /* "*" or "%" */

u8 matchOne; /* "?" or "_" */

u8 matchSet; /* "[" or 0 */

u8 noCase; /* true to ignore case differences */

};

/*

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

** character is exactly one byte in size. Also, provde the Utf8Read()

** macro for fast reading of the next character in the common case where

** the next character is ASCII.

*/

#if defined(SQLITE_EBCDIC)

# define sqlite3Utf8Read(A) (*((*A)++))

# define Utf8Read(A) (*(A++))

#else

# define Utf8Read(A) (A[0]<0x80?*(A++):sqlite3Utf8Read(&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 };

/*

** Possible error returns from patternMatch()

*/

#define SQLITE_MATCH 0

#define SQLITE_NOMATCH 1

#define SQLITE_NOWILDCARDMATCH 2

/*

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

** a GLOB or LIKE expression. Return values:

**

** SQLITE_MATCH: Match

** SQLITE_NOMATCH: No match

** SQLITE_NOWILDCARDMATCH: No match in spite of having * or % wildcards.

**

** 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.

**

** Like matching rules:

**

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

**

*** '_' Matches any one character

**

** Ec Where E is the "esc" character and c is any other

** character, including '%', '_', and esc, match exactly c.

**

** The comments within this routine usually assume glob matching.

**

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

*/

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 */

u32 matchOther /* The escape char (LIKE) or '[' (GLOB) */

){

u32 c, c2; /* Next pattern and input string chars */

u32 matchOne = pInfo->matchOne; /* "?" or "_" */

u32 matchAll = pInfo->matchAll; /* "*" or "%" */

u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */

const u8 *zEscaped = 0; /* One past the last escaped input char */

while( (c = Utf8Read(zPattern))!=0 ){

if( c==matchAll ){ /* Match "*" */

/* Skip over multiple "*" characters in the pattern. If there

** are also "?" characters, skip those as well, but consume a

** single character of the input string for each "?" skipped */

while( (c=Utf8Read(zPattern)) == matchAll || c == matchOne ){

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

return SQLITE_NOWILDCARDMATCH;

}

}

if( c==0 ){

return SQLITE_MATCH; /* "*" at the end of the pattern matches */

}else if( c==matchOther ){

if( pInfo->matchSet==0 ){

c = sqlite3Utf8Read(&zPattern);

if( c==0 ) return SQLITE_NOWILDCARDMATCH;

}else{

/* "[...]" immediately follows the "*". We have to do a slow

** recursive search in this case, but it is an unusual case. */

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

while( *zString ){

int bMatch = patternCompare(&zPattern[-1],zString,pInfo,matchOther);

if( bMatch!=SQLITE_NOMATCH ) return bMatch;

SQLITE_SKIP_UTF8(zString);

}

return SQLITE_NOWILDCARDMATCH;

}

}

/* At this point variable c contains the first character of the

** pattern string past the "*". Search in the input string for the

** first matching character and recursively continue the match from

** that point.

**

** For a case-insensitive search, set variable cx to be the same as

** c but in the other case and search the input string for either

** c or cx.

*/

if( c<=0x80 ){

char zStop[3];

int bMatch;

if( noCase ){

zStop[0] = sqlite3Toupper(c);

zStop[1] = sqlite3Tolower(c);

zStop[2] = 0;

}else{

zStop[0] = c;

zStop[1] = 0;

}

while(1){

zString += strcspn((const char*)zString, zStop);

if( zString[0]==0 ) break;

zString++;

bMatch = patternCompare(zPattern,zString,pInfo,matchOther);

if( bMatch!=SQLITE_NOMATCH ) return bMatch;

}

}else{

int bMatch;

while( (c2 = Utf8Read(zString))!=0 ){

if( c2!=c ) continue;

bMatch = patternCompare(zPattern,zString,pInfo,matchOther);

if( bMatch!=SQLITE_NOMATCH ) return bMatch;

}

}

return SQLITE_NOWILDCARDMATCH;

}

if( c==matchOther ){

if( pInfo->matchSet==0 ){

c = sqlite3Utf8Read(&zPattern);

if( c==0 ) return SQLITE_NOMATCH;

zEscaped = zPattern;

}else{

u32 prior_c = 0;

int seen = 0;

int invert = 0;

c = sqlite3Utf8Read(&zString);

if( c==0 ) return SQLITE_NOMATCH;

c2 = sqlite3Utf8Read(&zPattern);

if( c2=='^' ){

invert = 1;

c2 = sqlite3Utf8Read(&zPattern);

}

if( c2==']' ){

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

c2 = sqlite3Utf8Read(&zPattern);

}

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

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

c2 = sqlite3Utf8Read(&zPattern);

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

prior_c = 0;

}else{

if( c==c2 ){

seen = 1;

}

prior_c = c2;

}

c2 = sqlite3Utf8Read(&zPattern);

}

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

return SQLITE_NOMATCH;

}

continue;

}

}

c2 = Utf8Read(zString);

if( c==c2 ) continue;

if( noCase && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){

continue;

}

if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue;

return SQLITE_NOMATCH;

}

return *zString==0 ? SQLITE_MATCH : SQLITE_NOMATCH;

}

/*

** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and

** non-zero if there is no match.

*/

int sqlite3_strglob(const char *zGlobPattern, const char *zString){

return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '[');

}

/*

** The sqlite3_strlike() interface. Return 0 on a match and non-zero for

** a miss - like strcmp().

*/

int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){

return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc);

}

/*

** 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;

u32 escape;

int nPat;

sqlite3 *db = sqlite3_context_db_handle(context);

struct compareInfo *pInfo = sqlite3_user_data(context);

#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS

if( sqlite3_value_type(argv[0])==SQLITE_BLOB

|| sqlite3_value_type(argv[1])==SQLITE_BLOB

){

#ifdef SQLITE_TEST

sqlite3_like_count++;

#endif

sqlite3_result_int(context, 0);

return;

}

#endif

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().

*/

nPat = sqlite3_value_bytes(argv[0]);

testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );

testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );

if( nPat > 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);

}else{

escape = pInfo->matchSet;

}

if( zA && zB ){

#ifdef SQLITE_TEST

sqlite3_like_count++;

#endif

sqlite3_result_int(context,

patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH);

}

}

/*

** 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 NotUsed,

sqlite3_value **argv

){

CollSeq *pColl = sqlite3GetFuncCollSeq(context);

UNUSED_PARAMETER(NotUsed);

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

sqlite3_result_value(context, argv[0]);

}

}

/*

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

** of the SQLite library that is running.

*/

static void versionFunc(

sqlite3_context *context,

int NotUsed,

sqlite3_value **NotUsed2

){

UNUSED_PARAMETER2(NotUsed, NotUsed2);

/* IMP: R-48699-48617 This function is an SQL wrapper around the

** sqlite3_libversion() C-interface. */

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

}

/*

** Implementation of the sqlite_source_id() function. The result is a string

** that identifies the particular version of the source code used to build

** SQLite.

*/

static void sourceidFunc(

sqlite3_context *context,

int NotUsed,

sqlite3_value **NotUsed2

){

UNUSED_PARAMETER2(NotUsed, NotUsed2);

/* IMP: R-24470-31136 This function is an SQL wrapper around the

** sqlite3_sourceid() C interface. */

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

}

/*

** Implementation of the sqlite_log() function. This is a wrapper around

** sqlite3_log(). The return value is NULL. The function exists purely for

** its side-effects.

*/

static void errlogFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

UNUSED_PARAMETER(argc);

UNUSED_PARAMETER(context);

sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1]));

}

/*

** Implementation of the sqlite_compileoption_used() function.

** The result is an integer that identifies if the compiler option

** was used to build SQLite.

*/

#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS

static void compileoptionusedFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

const char *zOptName;

assert( argc==1 );

UNUSED_PARAMETER(argc);

/* IMP: R-39564-36305 The sqlite_compileoption_used() SQL

** function is a wrapper around the sqlite3_compileoption_used() C/C++

** function.

*/

if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){

sqlite3_result_int(context, sqlite3_compileoption_used(zOptName));

}

}

#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */

/*

** Implementation of the sqlite_compileoption_get() function.

** The result is a string that identifies the compiler options

** used to build SQLite.

*/

#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS

static void compileoptiongetFunc(

sqlite3_context *context,

int argc,

sqlite3_value **argv

){

int n;

assert( argc==1 );

UNUSED_PARAMETER(argc);

/* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function

** is a wrapper around the sqlite3_compileoption_get() C/C++ function.

*/

n = sqlite3_value_int(argv[0]);

sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC);

}

#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */

/* 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'

};

/*

** 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