1.1 --- a/extensions/sqlite/sqlite-source/func.c Fri Jul 11 06:51:21 2008 +0000
1.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
1.3 @@ -1,1509 +0,0 @@
1.4 -/*
1.5 -** 2002 February 23
1.6 -**
1.7 -** The author disclaims copyright to this source code. In place of
1.8 -** a legal notice, here is a blessing:
1.9 -**
1.10 -** May you do good and not evil.
1.11 -** May you find forgiveness for yourself and forgive others.
1.12 -** May you share freely, never taking more than you give.
1.13 -**
1.14 -*************************************************************************
1.15 -** This file contains the C functions that implement various SQL
1.16 -** functions of SQLite.
1.17 -**
1.18 -** There is only one exported symbol in this file - the function
1.19 -** sqliteRegisterBuildinFunctions() found at the bottom of the file.
1.20 -** All other code has file scope.
1.21 -**
1.22 -** $Id$
1.23 -*/
1.24 -#include "sqliteInt.h"
1.25 -#include <ctype.h>
1.26 -#include <stdlib.h>
1.27 -#include <assert.h>
1.28 -#include "vdbeInt.h"
1.29 -
1.30 -
1.31 -/*
1.32 -** Return the collating function associated with a function.
1.33 -*/
1.34 -static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){
1.35 - return context->pColl;
1.36 -}
1.37 -
1.38 -/*
1.39 -** Implementation of the non-aggregate min() and max() functions
1.40 -*/
1.41 -static void minmaxFunc(
1.42 - sqlite3_context *context,
1.43 - int argc,
1.44 - sqlite3_value **argv
1.45 -){
1.46 - int i;
1.47 - int mask; /* 0 for min() or 0xffffffff for max() */
1.48 - int iBest;
1.49 - CollSeq *pColl;
1.50 -
1.51 - if( argc==0 ) return;
1.52 - mask = sqlite3_user_data(context)==0 ? 0 : -1;
1.53 - pColl = sqlite3GetFuncCollSeq(context);
1.54 - assert( pColl );
1.55 - assert( mask==-1 || mask==0 );
1.56 - iBest = 0;
1.57 - if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1.58 - for(i=1; i<argc; i++){
1.59 - if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;
1.60 - if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
1.61 - iBest = i;
1.62 - }
1.63 - }
1.64 - sqlite3_result_value(context, argv[iBest]);
1.65 -}
1.66 -
1.67 -/*
1.68 -** Return the type of the argument.
1.69 -*/
1.70 -static void typeofFunc(
1.71 - sqlite3_context *context,
1.72 - int argc,
1.73 - sqlite3_value **argv
1.74 -){
1.75 - const char *z = 0;
1.76 - switch( sqlite3_value_type(argv[0]) ){
1.77 - case SQLITE_NULL: z = "null"; break;
1.78 - case SQLITE_INTEGER: z = "integer"; break;
1.79 - case SQLITE_TEXT: z = "text"; break;
1.80 - case SQLITE_FLOAT: z = "real"; break;
1.81 - case SQLITE_BLOB: z = "blob"; break;
1.82 - }
1.83 - sqlite3_result_text(context, z, -1, SQLITE_STATIC);
1.84 -}
1.85 -
1.86 -
1.87 -/*
1.88 -** Implementation of the length() function
1.89 -*/
1.90 -static void lengthFunc(
1.91 - sqlite3_context *context,
1.92 - int argc,
1.93 - sqlite3_value **argv
1.94 -){
1.95 - int len;
1.96 -
1.97 - assert( argc==1 );
1.98 - switch( sqlite3_value_type(argv[0]) ){
1.99 - case SQLITE_BLOB:
1.100 - case SQLITE_INTEGER:
1.101 - case SQLITE_FLOAT: {
1.102 - sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
1.103 - break;
1.104 - }
1.105 - case SQLITE_TEXT: {
1.106 - const unsigned char *z = sqlite3_value_text(argv[0]);
1.107 - if( z==0 ) return;
1.108 - len = 0;
1.109 - while( *z ){
1.110 - len++;
1.111 - SQLITE_SKIP_UTF8(z);
1.112 - }
1.113 - sqlite3_result_int(context, len);
1.114 - break;
1.115 - }
1.116 - default: {
1.117 - sqlite3_result_null(context);
1.118 - break;
1.119 - }
1.120 - }
1.121 -}
1.122 -
1.123 -/*
1.124 -** Implementation of the abs() function
1.125 -*/
1.126 -static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
1.127 - assert( argc==1 );
1.128 - switch( sqlite3_value_type(argv[0]) ){
1.129 - case SQLITE_INTEGER: {
1.130 - i64 iVal = sqlite3_value_int64(argv[0]);
1.131 - if( iVal<0 ){
1.132 - if( (iVal<<1)==0 ){
1.133 - sqlite3_result_error(context, "integer overflow", -1);
1.134 - return;
1.135 - }
1.136 - iVal = -iVal;
1.137 - }
1.138 - sqlite3_result_int64(context, iVal);
1.139 - break;
1.140 - }
1.141 - case SQLITE_NULL: {
1.142 - sqlite3_result_null(context);
1.143 - break;
1.144 - }
1.145 - default: {
1.146 - double rVal = sqlite3_value_double(argv[0]);
1.147 - if( rVal<0 ) rVal = -rVal;
1.148 - sqlite3_result_double(context, rVal);
1.149 - break;
1.150 - }
1.151 - }
1.152 -}
1.153 -
1.154 -/*
1.155 -** Implementation of the substr() function.
1.156 -**
1.157 -** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
1.158 -** p1 is 1-indexed. So substr(x,1,1) returns the first character
1.159 -** of x. If x is text, then we actually count UTF-8 characters.
1.160 -** If x is a blob, then we count bytes.
1.161 -**
1.162 -** If p1 is negative, then we begin abs(p1) from the end of x[].
1.163 -*/
1.164 -static void substrFunc(
1.165 - sqlite3_context *context,
1.166 - int argc,
1.167 - sqlite3_value **argv
1.168 -){
1.169 - const unsigned char *z;
1.170 - const unsigned char *z2;
1.171 - int len;
1.172 - int p0type;
1.173 - i64 p1, p2;
1.174 -
1.175 - assert( argc==3 );
1.176 - p0type = sqlite3_value_type(argv[0]);
1.177 - if( p0type==SQLITE_BLOB ){
1.178 - len = sqlite3_value_bytes(argv[0]);
1.179 - z = sqlite3_value_blob(argv[0]);
1.180 - if( z==0 ) return;
1.181 - assert( len==sqlite3_value_bytes(argv[0]) );
1.182 - }else{
1.183 - z = sqlite3_value_text(argv[0]);
1.184 - if( z==0 ) return;
1.185 - len = 0;
1.186 - for(z2=z; *z2; len++){
1.187 - SQLITE_SKIP_UTF8(z2);
1.188 - }
1.189 - }
1.190 - p1 = sqlite3_value_int(argv[1]);
1.191 - p2 = sqlite3_value_int(argv[2]);
1.192 - if( p1<0 ){
1.193 - p1 += len;
1.194 - if( p1<0 ){
1.195 - p2 += p1;
1.196 - p1 = 0;
1.197 - }
1.198 - }else if( p1>0 ){
1.199 - p1--;
1.200 - }
1.201 - if( p1+p2>len ){
1.202 - p2 = len-p1;
1.203 - }
1.204 - if( p0type!=SQLITE_BLOB ){
1.205 - while( *z && p1 ){
1.206 - SQLITE_SKIP_UTF8(z);
1.207 - p1--;
1.208 - }
1.209 - for(z2=z; *z2 && p2; p2--){
1.210 - SQLITE_SKIP_UTF8(z2);
1.211 - }
1.212 - sqlite3_result_text(context, (char*)z, z2-z, SQLITE_TRANSIENT);
1.213 - }else{
1.214 - if( p2<0 ) p2 = 0;
1.215 - sqlite3_result_blob(context, (char*)&z[p1], p2, SQLITE_TRANSIENT);
1.216 - }
1.217 -}
1.218 -
1.219 -/*
1.220 -** Implementation of the round() function
1.221 -*/
1.222 -static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
1.223 - int n = 0;
1.224 - double r;
1.225 - char zBuf[500]; /* larger than the %f representation of the largest double */
1.226 - assert( argc==1 || argc==2 );
1.227 - if( argc==2 ){
1.228 - if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
1.229 - n = sqlite3_value_int(argv[1]);
1.230 - if( n>30 ) n = 30;
1.231 - if( n<0 ) n = 0;
1.232 - }
1.233 - if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1.234 - r = sqlite3_value_double(argv[0]);
1.235 - sqlite3_snprintf(sizeof(zBuf),zBuf,"%.*f",n,r);
1.236 - sqlite3AtoF(zBuf, &r);
1.237 - sqlite3_result_double(context, r);
1.238 -}
1.239 -
1.240 -/*
1.241 -** Allocate nByte bytes of space using sqlite3_malloc(). If the
1.242 -** allocation fails, call sqlite3_result_error_nomem() to notify
1.243 -** the database handle that malloc() has failed.
1.244 -*/
1.245 -static void *contextMalloc(sqlite3_context *context, int nByte){
1.246 - char *z = sqlite3_malloc(nByte);
1.247 - if( !z && nByte>0 ){
1.248 - sqlite3_result_error_nomem(context);
1.249 - }
1.250 - return z;
1.251 -}
1.252 -
1.253 -/*
1.254 -** Implementation of the upper() and lower() SQL functions.
1.255 -*/
1.256 -static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
1.257 - char *z1;
1.258 - const char *z2;
1.259 - int i, n;
1.260 - if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
1.261 - z2 = (char*)sqlite3_value_text(argv[0]);
1.262 - n = sqlite3_value_bytes(argv[0]);
1.263 - /* Verify that the call to _bytes() does not invalidate the _text() pointer */
1.264 - assert( z2==(char*)sqlite3_value_text(argv[0]) );
1.265 - if( z2 ){
1.266 - z1 = contextMalloc(context, n+1);
1.267 - if( z1 ){
1.268 - memcpy(z1, z2, n+1);
1.269 - for(i=0; z1[i]; i++){
1.270 - z1[i] = toupper(z1[i]);
1.271 - }
1.272 - sqlite3_result_text(context, z1, -1, sqlite3_free);
1.273 - }
1.274 - }
1.275 -}
1.276 -static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
1.277 - char *z1;
1.278 - const char *z2;
1.279 - int i, n;
1.280 - if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
1.281 - z2 = (char*)sqlite3_value_text(argv[0]);
1.282 - n = sqlite3_value_bytes(argv[0]);
1.283 - /* Verify that the call to _bytes() does not invalidate the _text() pointer */
1.284 - assert( z2==(char*)sqlite3_value_text(argv[0]) );
1.285 - if( z2 ){
1.286 - z1 = contextMalloc(context, n+1);
1.287 - if( z1 ){
1.288 - memcpy(z1, z2, n+1);
1.289 - for(i=0; z1[i]; i++){
1.290 - z1[i] = tolower(z1[i]);
1.291 - }
1.292 - sqlite3_result_text(context, z1, -1, sqlite3_free);
1.293 - }
1.294 - }
1.295 -}
1.296 -
1.297 -/*
1.298 -** Implementation of the IFNULL(), NVL(), and COALESCE() functions.
1.299 -** All three do the same thing. They return the first non-NULL
1.300 -** argument.
1.301 -*/
1.302 -static void ifnullFunc(
1.303 - sqlite3_context *context,
1.304 - int argc,
1.305 - sqlite3_value **argv
1.306 -){
1.307 - int i;
1.308 - for(i=0; i<argc; i++){
1.309 - if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){
1.310 - sqlite3_result_value(context, argv[i]);
1.311 - break;
1.312 - }
1.313 - }
1.314 -}
1.315 -
1.316 -/*
1.317 -** Implementation of random(). Return a random integer.
1.318 -*/
1.319 -static void randomFunc(
1.320 - sqlite3_context *context,
1.321 - int argc,
1.322 - sqlite3_value **argv
1.323 -){
1.324 - sqlite_int64 r;
1.325 - sqlite3Randomness(sizeof(r), &r);
1.326 - if( (r<<1)==0 ) r = 0; /* Prevent 0x8000.... as the result so that we */
1.327 - /* can always do abs() of the result */
1.328 - sqlite3_result_int64(context, r);
1.329 -}
1.330 -
1.331 -/*
1.332 -** Implementation of randomblob(N). Return a random blob
1.333 -** that is N bytes long.
1.334 -*/
1.335 -static void randomBlob(
1.336 - sqlite3_context *context,
1.337 - int argc,
1.338 - sqlite3_value **argv
1.339 -){
1.340 - int n;
1.341 - unsigned char *p;
1.342 - assert( argc==1 );
1.343 - n = sqlite3_value_int(argv[0]);
1.344 - if( n<1 ){
1.345 - n = 1;
1.346 - }
1.347 - if( n>SQLITE_MAX_LENGTH ){
1.348 - sqlite3_result_error_toobig(context);
1.349 - return;
1.350 - }
1.351 - p = contextMalloc(context, n);
1.352 - if( p ){
1.353 - sqlite3Randomness(n, p);
1.354 - sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
1.355 - }
1.356 -}
1.357 -
1.358 -/*
1.359 -** Implementation of the last_insert_rowid() SQL function. The return
1.360 -** value is the same as the sqlite3_last_insert_rowid() API function.
1.361 -*/
1.362 -static void last_insert_rowid(
1.363 - sqlite3_context *context,
1.364 - int arg,
1.365 - sqlite3_value **argv
1.366 -){
1.367 - sqlite3 *db = sqlite3_user_data(context);
1.368 - sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
1.369 -}
1.370 -
1.371 -/*
1.372 -** Implementation of the changes() SQL function. The return value is the
1.373 -** same as the sqlite3_changes() API function.
1.374 -*/
1.375 -static void changes(
1.376 - sqlite3_context *context,
1.377 - int arg,
1.378 - sqlite3_value **argv
1.379 -){
1.380 - sqlite3 *db = sqlite3_user_data(context);
1.381 - sqlite3_result_int(context, sqlite3_changes(db));
1.382 -}
1.383 -
1.384 -/*
1.385 -** Implementation of the total_changes() SQL function. The return value is
1.386 -** the same as the sqlite3_total_changes() API function.
1.387 -*/
1.388 -static void total_changes(
1.389 - sqlite3_context *context,
1.390 - int arg,
1.391 - sqlite3_value **argv
1.392 -){
1.393 - sqlite3 *db = sqlite3_user_data(context);
1.394 - sqlite3_result_int(context, sqlite3_total_changes(db));
1.395 -}
1.396 -
1.397 -/*
1.398 -** A structure defining how to do GLOB-style comparisons.
1.399 -*/
1.400 -struct compareInfo {
1.401 - u8 matchAll;
1.402 - u8 matchOne;
1.403 - u8 matchSet;
1.404 - u8 noCase;
1.405 -};
1.406 -
1.407 -static const struct compareInfo globInfo = { '*', '?', '[', 0 };
1.408 -/* The correct SQL-92 behavior is for the LIKE operator to ignore
1.409 -** case. Thus 'a' LIKE 'A' would be true. */
1.410 -static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 };
1.411 -/* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
1.412 -** is case sensitive causing 'a' LIKE 'A' to be false */
1.413 -static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 };
1.414 -
1.415 -/*
1.416 -** Compare two UTF-8 strings for equality where the first string can
1.417 -** potentially be a "glob" expression. Return true (1) if they
1.418 -** are the same and false (0) if they are different.
1.419 -**
1.420 -** Globbing rules:
1.421 -**
1.422 -** '*' Matches any sequence of zero or more characters.
1.423 -**
1.424 -** '?' Matches exactly one character.
1.425 -**
1.426 -** [...] Matches one character from the enclosed list of
1.427 -** characters.
1.428 -**
1.429 -** [^...] Matches one character not in the enclosed list.
1.430 -**
1.431 -** With the [...] and [^...] matching, a ']' character can be included
1.432 -** in the list by making it the first character after '[' or '^'. A
1.433 -** range of characters can be specified using '-'. Example:
1.434 -** "[a-z]" matches any single lower-case letter. To match a '-', make
1.435 -** it the last character in the list.
1.436 -**
1.437 -** This routine is usually quick, but can be N**2 in the worst case.
1.438 -**
1.439 -** Hints: to match '*' or '?', put them in "[]". Like this:
1.440 -**
1.441 -** abc[*]xyz Matches "abc*xyz" only
1.442 -*/
1.443 -static int patternCompare(
1.444 - const u8 *zPattern, /* The glob pattern */
1.445 - const u8 *zString, /* The string to compare against the glob */
1.446 - const struct compareInfo *pInfo, /* Information about how to do the compare */
1.447 - const int esc /* The escape character */
1.448 -){
1.449 - int c, c2;
1.450 - int invert;
1.451 - int seen;
1.452 - u8 matchOne = pInfo->matchOne;
1.453 - u8 matchAll = pInfo->matchAll;
1.454 - u8 matchSet = pInfo->matchSet;
1.455 - u8 noCase = pInfo->noCase;
1.456 - int prevEscape = 0; /* True if the previous character was 'escape' */
1.457 -
1.458 - while( (c = sqlite3Utf8Read(zPattern,0,&zPattern))!=0 ){
1.459 - if( !prevEscape && c==matchAll ){
1.460 - while( (c=sqlite3Utf8Read(zPattern,0,&zPattern)) == matchAll
1.461 - || c == matchOne ){
1.462 - if( c==matchOne && sqlite3Utf8Read(zString, 0, &zString)==0 ){
1.463 - return 0;
1.464 - }
1.465 - }
1.466 - if( c==0 ){
1.467 - return 1;
1.468 - }else if( c==esc ){
1.469 - c = sqlite3Utf8Read(zPattern, 0, &zPattern);
1.470 - if( c==0 ){
1.471 - return 0;
1.472 - }
1.473 - }else if( c==matchSet ){
1.474 - assert( esc==0 ); /* This is GLOB, not LIKE */
1.475 - assert( matchSet<0x80 ); /* '[' is a single-byte character */
1.476 - while( *zString && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){
1.477 - SQLITE_SKIP_UTF8(zString);
1.478 - }
1.479 - return *zString!=0;
1.480 - }
1.481 - while( (c2 = sqlite3Utf8Read(zString,0,&zString))!=0 ){
1.482 - if( noCase ){
1.483 - c2 = c2<0x80 ? sqlite3UpperToLower[c2] : c2;
1.484 - c = c<0x80 ? sqlite3UpperToLower[c] : c;
1.485 - while( c2 != 0 && c2 != c ){
1.486 - c2 = sqlite3Utf8Read(zString, 0, &zString);
1.487 - if( c2<0x80 ) c2 = sqlite3UpperToLower[c2];
1.488 - }
1.489 - }else{
1.490 - while( c2 != 0 && c2 != c ){
1.491 - c2 = sqlite3Utf8Read(zString, 0, &zString);
1.492 - }
1.493 - }
1.494 - if( c2==0 ) return 0;
1.495 - if( patternCompare(zPattern,zString,pInfo,esc) ) return 1;
1.496 - }
1.497 - return 0;
1.498 - }else if( !prevEscape && c==matchOne ){
1.499 - if( sqlite3Utf8Read(zString, 0, &zString)==0 ){
1.500 - return 0;
1.501 - }
1.502 - }else if( c==matchSet ){
1.503 - int prior_c = 0;
1.504 - assert( esc==0 ); /* This only occurs for GLOB, not LIKE */
1.505 - seen = 0;
1.506 - invert = 0;
1.507 - c = sqlite3Utf8Read(zString, 0, &zString);
1.508 - if( c==0 ) return 0;
1.509 - c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
1.510 - if( c2=='^' ){
1.511 - invert = 1;
1.512 - c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
1.513 - }
1.514 - if( c2==']' ){
1.515 - if( c==']' ) seen = 1;
1.516 - c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
1.517 - }
1.518 - while( c2 && c2!=']' ){
1.519 - if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
1.520 - c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
1.521 - if( c>=prior_c && c<=c2 ) seen = 1;
1.522 - prior_c = 0;
1.523 - }else{
1.524 - if( c==c2 ){
1.525 - seen = 1;
1.526 - }
1.527 - prior_c = c2;
1.528 - }
1.529 - c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
1.530 - }
1.531 - if( c2==0 || (seen ^ invert)==0 ){
1.532 - return 0;
1.533 - }
1.534 - }else if( esc==c && !prevEscape ){
1.535 - prevEscape = 1;
1.536 - }else{
1.537 - c2 = sqlite3Utf8Read(zString, 0, &zString);
1.538 - if( noCase ){
1.539 - c = c<0x80 ? sqlite3UpperToLower[c] : c;
1.540 - c2 = c2<0x80 ? sqlite3UpperToLower[c2] : c2;
1.541 - }
1.542 - if( c!=c2 ){
1.543 - return 0;
1.544 - }
1.545 - prevEscape = 0;
1.546 - }
1.547 - }
1.548 - return *zString==0;
1.549 -}
1.550 -
1.551 -/*
1.552 -** Count the number of times that the LIKE operator (or GLOB which is
1.553 -** just a variation of LIKE) gets called. This is used for testing
1.554 -** only.
1.555 -*/
1.556 -#ifdef SQLITE_TEST
1.557 -int sqlite3_like_count = 0;
1.558 -#endif
1.559 -
1.560 -
1.561 -/*
1.562 -** Implementation of the like() SQL function. This function implements
1.563 -** the build-in LIKE operator. The first argument to the function is the
1.564 -** pattern and the second argument is the string. So, the SQL statements:
1.565 -**
1.566 -** A LIKE B
1.567 -**
1.568 -** is implemented as like(B,A).
1.569 -**
1.570 -** This same function (with a different compareInfo structure) computes
1.571 -** the GLOB operator.
1.572 -*/
1.573 -static void likeFunc(
1.574 - sqlite3_context *context,
1.575 - int argc,
1.576 - sqlite3_value **argv
1.577 -){
1.578 - const unsigned char *zA, *zB;
1.579 - int escape = 0;
1.580 -
1.581 - zB = sqlite3_value_text(argv[0]);
1.582 - zA = sqlite3_value_text(argv[1]);
1.583 -
1.584 - /* Limit the length of the LIKE or GLOB pattern to avoid problems
1.585 - ** of deep recursion and N*N behavior in patternCompare().
1.586 - */
1.587 - if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){
1.588 - sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
1.589 - return;
1.590 - }
1.591 - assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */
1.592 -
1.593 - if( argc==3 ){
1.594 - /* The escape character string must consist of a single UTF-8 character.
1.595 - ** Otherwise, return an error.
1.596 - */
1.597 - const unsigned char *zEsc = sqlite3_value_text(argv[2]);
1.598 - if( zEsc==0 ) return;
1.599 - if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
1.600 - sqlite3_result_error(context,
1.601 - "ESCAPE expression must be a single character", -1);
1.602 - return;
1.603 - }
1.604 - escape = sqlite3Utf8Read(zEsc, 0, &zEsc);
1.605 - }
1.606 - if( zA && zB ){
1.607 - struct compareInfo *pInfo = sqlite3_user_data(context);
1.608 -#ifdef SQLITE_TEST
1.609 - sqlite3_like_count++;
1.610 -#endif
1.611 -
1.612 - sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape));
1.613 - }
1.614 -}
1.615 -
1.616 -/*
1.617 -** Implementation of the NULLIF(x,y) function. The result is the first
1.618 -** argument if the arguments are different. The result is NULL if the
1.619 -** arguments are equal to each other.
1.620 -*/
1.621 -static void nullifFunc(
1.622 - sqlite3_context *context,
1.623 - int argc,
1.624 - sqlite3_value **argv
1.625 -){
1.626 - CollSeq *pColl = sqlite3GetFuncCollSeq(context);
1.627 - if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
1.628 - sqlite3_result_value(context, argv[0]);
1.629 - }
1.630 -}
1.631 -
1.632 -/*
1.633 -** Implementation of the VERSION(*) function. The result is the version
1.634 -** of the SQLite library that is running.
1.635 -*/
1.636 -static void versionFunc(
1.637 - sqlite3_context *context,
1.638 - int argc,
1.639 - sqlite3_value **argv
1.640 -){
1.641 - sqlite3_result_text(context, sqlite3_version, -1, SQLITE_STATIC);
1.642 -}
1.643 -
1.644 -/* Array for converting from half-bytes (nybbles) into ASCII hex
1.645 -** digits. */
1.646 -static const char hexdigits[] = {
1.647 - '0', '1', '2', '3', '4', '5', '6', '7',
1.648 - '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
1.649 -};
1.650 -
1.651 -/*
1.652 -** EXPERIMENTAL - This is not an official function. The interface may
1.653 -** change. This function may disappear. Do not write code that depends
1.654 -** on this function.
1.655 -**
1.656 -** Implementation of the QUOTE() function. This function takes a single
1.657 -** argument. If the argument is numeric, the return value is the same as
1.658 -** the argument. If the argument is NULL, the return value is the string
1.659 -** "NULL". Otherwise, the argument is enclosed in single quotes with
1.660 -** single-quote escapes.
1.661 -*/
1.662 -static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
1.663 - if( argc<1 ) return;
1.664 - switch( sqlite3_value_type(argv[0]) ){
1.665 - case SQLITE_NULL: {
1.666 - sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);
1.667 - break;
1.668 - }
1.669 - case SQLITE_INTEGER:
1.670 - case SQLITE_FLOAT: {
1.671 - sqlite3_result_value(context, argv[0]);
1.672 - break;
1.673 - }
1.674 - case SQLITE_BLOB: {
1.675 - char *zText = 0;
1.676 - char const *zBlob = sqlite3_value_blob(argv[0]);
1.677 - int nBlob = sqlite3_value_bytes(argv[0]);
1.678 - assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
1.679 -
1.680 - if( 2*nBlob+4>SQLITE_MAX_LENGTH ){
1.681 - sqlite3_result_error_toobig(context);
1.682 - return;
1.683 - }
1.684 - zText = (char *)contextMalloc(context, (2*nBlob)+4);
1.685 - if( zText ){
1.686 - int i;
1.687 - for(i=0; i<nBlob; i++){
1.688 - zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
1.689 - zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
1.690 - }
1.691 - zText[(nBlob*2)+2] = '\'';
1.692 - zText[(nBlob*2)+3] = '\0';
1.693 - zText[0] = 'X';
1.694 - zText[1] = '\'';
1.695 - sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
1.696 - sqlite3_free(zText);
1.697 - }
1.698 - break;
1.699 - }
1.700 - case SQLITE_TEXT: {
1.701 - int i,j;
1.702 - u64 n;
1.703 - const unsigned char *zArg = sqlite3_value_text(argv[0]);
1.704 - char *z;
1.705 -
1.706 - if( zArg==0 ) return;
1.707 - for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }
1.708 - if( i+n+3>SQLITE_MAX_LENGTH ){
1.709 - sqlite3_result_error_toobig(context);
1.710 - return;
1.711 - }
1.712 - z = contextMalloc(context, i+n+3);
1.713 - if( z ){
1.714 - z[0] = '\'';
1.715 - for(i=0, j=1; zArg[i]; i++){
1.716 - z[j++] = zArg[i];
1.717 - if( zArg[i]=='\'' ){
1.718 - z[j++] = '\'';
1.719 - }
1.720 - }
1.721 - z[j++] = '\'';
1.722 - z[j] = 0;
1.723 - sqlite3_result_text(context, z, j, sqlite3_free);
1.724 - }
1.725 - }
1.726 - }
1.727 -}
1.728 -
1.729 -/*
1.730 -** The hex() function. Interpret the argument as a blob. Return
1.731 -** a hexadecimal rendering as text.
1.732 -*/
1.733 -static void hexFunc(
1.734 - sqlite3_context *context,
1.735 - int argc,
1.736 - sqlite3_value **argv
1.737 -){
1.738 - int i, n;
1.739 - const unsigned char *pBlob;
1.740 - char *zHex, *z;
1.741 - assert( argc==1 );
1.742 - pBlob = sqlite3_value_blob(argv[0]);
1.743 - n = sqlite3_value_bytes(argv[0]);
1.744 - if( n*2+1>SQLITE_MAX_LENGTH ){
1.745 - sqlite3_result_error_toobig(context);
1.746 - return;
1.747 - }
1.748 - assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
1.749 - z = zHex = contextMalloc(context, n*2 + 1);
1.750 - if( zHex ){
1.751 - for(i=0; i<n; i++, pBlob++){
1.752 - unsigned char c = *pBlob;
1.753 - *(z++) = hexdigits[(c>>4)&0xf];
1.754 - *(z++) = hexdigits[c&0xf];
1.755 - }
1.756 - *z = 0;
1.757 - sqlite3_result_text(context, zHex, n*2, sqlite3_free);
1.758 - }
1.759 -}
1.760 -
1.761 -/*
1.762 -** The zeroblob(N) function returns a zero-filled blob of size N bytes.
1.763 -*/
1.764 -static void zeroblobFunc(
1.765 - sqlite3_context *context,
1.766 - int argc,
1.767 - sqlite3_value **argv
1.768 -){
1.769 - i64 n;
1.770 - assert( argc==1 );
1.771 - n = sqlite3_value_int64(argv[0]);
1.772 - if( n>SQLITE_MAX_LENGTH ){
1.773 - sqlite3_result_error_toobig(context);
1.774 - }else{
1.775 - sqlite3_result_zeroblob(context, n);
1.776 - }
1.777 -}
1.778 -
1.779 -/*
1.780 -** The replace() function. Three arguments are all strings: call
1.781 -** them A, B, and C. The result is also a string which is derived
1.782 -** from A by replacing every occurance of B with C. The match
1.783 -** must be exact. Collating sequences are not used.
1.784 -*/
1.785 -static void replaceFunc(
1.786 - sqlite3_context *context,
1.787 - int argc,
1.788 - sqlite3_value **argv
1.789 -){
1.790 - const unsigned char *zStr; /* The input string A */
1.791 - const unsigned char *zPattern; /* The pattern string B */
1.792 - const unsigned char *zRep; /* The replacement string C */
1.793 - unsigned char *zOut; /* The output */
1.794 - int nStr; /* Size of zStr */
1.795 - int nPattern; /* Size of zPattern */
1.796 - int nRep; /* Size of zRep */
1.797 - i64 nOut; /* Maximum size of zOut */
1.798 - int loopLimit; /* Last zStr[] that might match zPattern[] */
1.799 - int i, j; /* Loop counters */
1.800 -
1.801 - assert( argc==3 );
1.802 - zStr = sqlite3_value_text(argv[0]);
1.803 - if( zStr==0 ) return;
1.804 - nStr = sqlite3_value_bytes(argv[0]);
1.805 - assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */
1.806 - zPattern = sqlite3_value_text(argv[1]);
1.807 - if( zPattern==0 || zPattern[0]==0 ) return;
1.808 - nPattern = sqlite3_value_bytes(argv[1]);
1.809 - assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */
1.810 - zRep = sqlite3_value_text(argv[2]);
1.811 - if( zRep==0 ) return;
1.812 - nRep = sqlite3_value_bytes(argv[2]);
1.813 - assert( zRep==sqlite3_value_text(argv[2]) );
1.814 - nOut = nStr + 1;
1.815 - assert( nOut<SQLITE_MAX_LENGTH );
1.816 - zOut = contextMalloc(context, (int)nOut);
1.817 - if( zOut==0 ){
1.818 - return;
1.819 - }
1.820 - loopLimit = nStr - nPattern;
1.821 - for(i=j=0; i<=loopLimit; i++){
1.822 - if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
1.823 - zOut[j++] = zStr[i];
1.824 - }else{
1.825 - u8 *zOld;
1.826 - nOut += nRep - nPattern;
1.827 - if( nOut>=SQLITE_MAX_LENGTH ){
1.828 - sqlite3_result_error_toobig(context);
1.829 - sqlite3_free(zOut);
1.830 - return;
1.831 - }
1.832 - zOld = zOut;
1.833 - zOut = sqlite3_realloc(zOut, (int)nOut);
1.834 - if( zOut==0 ){
1.835 - sqlite3_result_error_nomem(context);
1.836 - sqlite3_free(zOld);
1.837 - return;
1.838 - }
1.839 - memcpy(&zOut[j], zRep, nRep);
1.840 - j += nRep;
1.841 - i += nPattern-1;
1.842 - }
1.843 - }
1.844 - assert( j+nStr-i+1==nOut );
1.845 - memcpy(&zOut[j], &zStr[i], nStr-i);
1.846 - j += nStr - i;
1.847 - assert( j<=nOut );
1.848 - zOut[j] = 0;
1.849 - sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
1.850 -}
1.851 -
1.852 -/*
1.853 -** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
1.854 -** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
1.855 -*/
1.856 -static void trimFunc(
1.857 - sqlite3_context *context,
1.858 - int argc,
1.859 - sqlite3_value **argv
1.860 -){
1.861 - const unsigned char *zIn; /* Input string */
1.862 - const unsigned char *zCharSet; /* Set of characters to trim */
1.863 - int nIn; /* Number of bytes in input */
1.864 - int flags; /* 1: trimleft 2: trimright 3: trim */
1.865 - int i; /* Loop counter */
1.866 - unsigned char *aLen; /* Length of each character in zCharSet */
1.867 - const unsigned char **azChar; /* Individual characters in zCharSet */
1.868 - int nChar; /* Number of characters in zCharSet */
1.869 -
1.870 - if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
1.871 - return;
1.872 - }
1.873 - zIn = sqlite3_value_text(argv[0]);
1.874 - if( zIn==0 ) return;
1.875 - nIn = sqlite3_value_bytes(argv[0]);
1.876 - assert( zIn==sqlite3_value_text(argv[0]) );
1.877 - if( argc==1 ){
1.878 - static const unsigned char lenOne[] = { 1 };
1.879 - static const unsigned char *azOne[] = { (u8*)" " };
1.880 - nChar = 1;
1.881 - aLen = (u8*)lenOne;
1.882 - azChar = azOne;
1.883 - zCharSet = 0;
1.884 - }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
1.885 - return;
1.886 - }else{
1.887 - const unsigned char *z;
1.888 - for(z=zCharSet, nChar=0; *z; nChar++){
1.889 - SQLITE_SKIP_UTF8(z);
1.890 - }
1.891 - if( nChar>0 ){
1.892 - azChar = contextMalloc(context, nChar*(sizeof(char*)+1));
1.893 - if( azChar==0 ){
1.894 - return;
1.895 - }
1.896 - aLen = (unsigned char*)&azChar[nChar];
1.897 - for(z=zCharSet, nChar=0; *z; nChar++){
1.898 - azChar[nChar] = z;
1.899 - SQLITE_SKIP_UTF8(z);
1.900 - aLen[nChar] = z - azChar[nChar];
1.901 - }
1.902 - }
1.903 - }
1.904 - if( nChar>0 ){
1.905 - flags = (int)sqlite3_user_data(context);
1.906 - if( flags & 1 ){
1.907 - while( nIn>0 ){
1.908 - int len;
1.909 - for(i=0; i<nChar; i++){
1.910 - len = aLen[i];
1.911 - if( memcmp(zIn, azChar[i], len)==0 ) break;
1.912 - }
1.913 - if( i>=nChar ) break;
1.914 - zIn += len;
1.915 - nIn -= len;
1.916 - }
1.917 - }
1.918 - if( flags & 2 ){
1.919 - while( nIn>0 ){
1.920 - int len;
1.921 - for(i=0; i<nChar; i++){
1.922 - len = aLen[i];
1.923 - if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
1.924 - }
1.925 - if( i>=nChar ) break;
1.926 - nIn -= len;
1.927 - }
1.928 - }
1.929 - if( zCharSet ){
1.930 - sqlite3_free(azChar);
1.931 - }
1.932 - }
1.933 - sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
1.934 -}
1.935 -
1.936 -#ifdef SQLITE_SOUNDEX
1.937 -/*
1.938 -** Compute the soundex encoding of a word.
1.939 -*/
1.940 -static void soundexFunc(
1.941 - sqlite3_context *context,
1.942 - int argc,
1.943 - sqlite3_value **argv
1.944 -){
1.945 - char zResult[8];
1.946 - const u8 *zIn;
1.947 - int i, j;
1.948 - static const unsigned char iCode[] = {
1.949 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1.950 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1.951 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1.952 - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1.953 - 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1.954 - 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1.955 - 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1.956 - 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1.957 - };
1.958 - assert( argc==1 );
1.959 - zIn = (u8*)sqlite3_value_text(argv[0]);
1.960 - if( zIn==0 ) zIn = (u8*)"";
1.961 - for(i=0; zIn[i] && !isalpha(zIn[i]); i++){}
1.962 - if( zIn[i] ){
1.963 - u8 prevcode = iCode[zIn[i]&0x7f];
1.964 - zResult[0] = toupper(zIn[i]);
1.965 - for(j=1; j<4 && zIn[i]; i++){
1.966 - int code = iCode[zIn[i]&0x7f];
1.967 - if( code>0 ){
1.968 - if( code!=prevcode ){
1.969 - prevcode = code;
1.970 - zResult[j++] = code + '0';
1.971 - }
1.972 - }else{
1.973 - prevcode = 0;
1.974 - }
1.975 - }
1.976 - while( j<4 ){
1.977 - zResult[j++] = '0';
1.978 - }
1.979 - zResult[j] = 0;
1.980 - sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
1.981 - }else{
1.982 - sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
1.983 - }
1.984 -}
1.985 -#endif
1.986 -
1.987 -#ifndef SQLITE_OMIT_LOAD_EXTENSION
1.988 -/*
1.989 -** A function that loads a shared-library extension then returns NULL.
1.990 -*/
1.991 -static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
1.992 - const char *zFile = (const char *)sqlite3_value_text(argv[0]);
1.993 - const char *zProc;
1.994 - sqlite3 *db = sqlite3_user_data(context);
1.995 - char *zErrMsg = 0;
1.996 -
1.997 - if( argc==2 ){
1.998 - zProc = (const char *)sqlite3_value_text(argv[1]);
1.999 - }else{
1.1000 - zProc = 0;
1.1001 - }
1.1002 - if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
1.1003 - sqlite3_result_error(context, zErrMsg, -1);
1.1004 - sqlite3_free(zErrMsg);
1.1005 - }
1.1006 -}
1.1007 -#endif
1.1008 -
1.1009 -#ifdef SQLITE_TEST
1.1010 -/*
1.1011 -** This function generates a string of random characters. Used for
1.1012 -** generating test data.
1.1013 -*/
1.1014 -static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){
1.1015 - static const unsigned char zSrc[] =
1.1016 - "abcdefghijklmnopqrstuvwxyz"
1.1017 - "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1.1018 - "0123456789"
1.1019 - ".-!,:*^+=_|?/<> ";
1.1020 - int iMin, iMax, n, r, i;
1.1021 - unsigned char zBuf[1000];
1.1022 -
1.1023 - /* It used to be possible to call randstr() with any number of arguments,
1.1024 - ** but now it is registered with SQLite as requiring exactly 2.
1.1025 - */
1.1026 - assert(argc==2);
1.1027 -
1.1028 - iMin = sqlite3_value_int(argv[0]);
1.1029 - if( iMin<0 ) iMin = 0;
1.1030 - if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1;
1.1031 - iMax = sqlite3_value_int(argv[1]);
1.1032 - if( iMax<iMin ) iMax = iMin;
1.1033 - if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1;
1.1034 - n = iMin;
1.1035 - if( iMax>iMin ){
1.1036 - sqlite3Randomness(sizeof(r), &r);
1.1037 - r &= 0x7fffffff;
1.1038 - n += r%(iMax + 1 - iMin);
1.1039 - }
1.1040 - assert( n<sizeof(zBuf) );
1.1041 - sqlite3Randomness(n, zBuf);
1.1042 - for(i=0; i<n; i++){
1.1043 - zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
1.1044 - }
1.1045 - zBuf[n] = 0;
1.1046 - sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT);
1.1047 -}
1.1048 -#endif /* SQLITE_TEST */
1.1049 -
1.1050 -#ifdef SQLITE_TEST
1.1051 -/*
1.1052 -** The following two SQL functions are used to test returning a text
1.1053 -** result with a destructor. Function 'test_destructor' takes one argument
1.1054 -** and returns the same argument interpreted as TEXT. A destructor is
1.1055 -** passed with the sqlite3_result_text() call.
1.1056 -**
1.1057 -** SQL function 'test_destructor_count' returns the number of outstanding
1.1058 -** allocations made by 'test_destructor';
1.1059 -**
1.1060 -** WARNING: Not threadsafe.
1.1061 -*/
1.1062 -static int test_destructor_count_var = 0;
1.1063 -static void destructor(void *p){
1.1064 - char *zVal = (char *)p;
1.1065 - assert(zVal);
1.1066 - zVal--;
1.1067 - sqlite3_free(zVal);
1.1068 - test_destructor_count_var--;
1.1069 -}
1.1070 -static void test_destructor(
1.1071 - sqlite3_context *pCtx,
1.1072 - int nArg,
1.1073 - sqlite3_value **argv
1.1074 -){
1.1075 - char *zVal;
1.1076 - int len;
1.1077 - sqlite3 *db = sqlite3_user_data(pCtx);
1.1078 -
1.1079 - test_destructor_count_var++;
1.1080 - assert( nArg==1 );
1.1081 - if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1.1082 - len = sqlite3ValueBytes(argv[0], ENC(db));
1.1083 - zVal = contextMalloc(pCtx, len+3);
1.1084 - if( !zVal ){
1.1085 - return;
1.1086 - }
1.1087 - zVal[len+1] = 0;
1.1088 - zVal[len+2] = 0;
1.1089 - zVal++;
1.1090 - memcpy(zVal, sqlite3ValueText(argv[0], ENC(db)), len);
1.1091 - if( ENC(db)==SQLITE_UTF8 ){
1.1092 - sqlite3_result_text(pCtx, zVal, -1, destructor);
1.1093 -#ifndef SQLITE_OMIT_UTF16
1.1094 - }else if( ENC(db)==SQLITE_UTF16LE ){
1.1095 - sqlite3_result_text16le(pCtx, zVal, -1, destructor);
1.1096 - }else{
1.1097 - sqlite3_result_text16be(pCtx, zVal, -1, destructor);
1.1098 -#endif /* SQLITE_OMIT_UTF16 */
1.1099 - }
1.1100 -}
1.1101 -static void test_destructor_count(
1.1102 - sqlite3_context *pCtx,
1.1103 - int nArg,
1.1104 - sqlite3_value **argv
1.1105 -){
1.1106 - sqlite3_result_int(pCtx, test_destructor_count_var);
1.1107 -}
1.1108 -#endif /* SQLITE_TEST */
1.1109 -
1.1110 -#ifdef SQLITE_TEST
1.1111 -/*
1.1112 -** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata()
1.1113 -** interface.
1.1114 -**
1.1115 -** The test_auxdata() SQL function attempts to register each of its arguments
1.1116 -** as auxiliary data. If there are no prior registrations of aux data for
1.1117 -** that argument (meaning the argument is not a constant or this is its first
1.1118 -** call) then the result for that argument is 0. If there is a prior
1.1119 -** registration, the result for that argument is 1. The overall result
1.1120 -** is the individual argument results separated by spaces.
1.1121 -*/
1.1122 -static void free_test_auxdata(void *p) {sqlite3_free(p);}
1.1123 -static void test_auxdata(
1.1124 - sqlite3_context *pCtx,
1.1125 - int nArg,
1.1126 - sqlite3_value **argv
1.1127 -){
1.1128 - int i;
1.1129 - char *zRet = contextMalloc(pCtx, nArg*2);
1.1130 - if( !zRet ) return;
1.1131 - memset(zRet, 0, nArg*2);
1.1132 - for(i=0; i<nArg; i++){
1.1133 - char const *z = (char*)sqlite3_value_text(argv[i]);
1.1134 - if( z ){
1.1135 - char *zAux = sqlite3_get_auxdata(pCtx, i);
1.1136 - if( zAux ){
1.1137 - zRet[i*2] = '1';
1.1138 - if( strcmp(zAux, z) ){
1.1139 - sqlite3_result_error(pCtx, "Auxilary data corruption", -1);
1.1140 - return;
1.1141 - }
1.1142 - }else {
1.1143 - zRet[i*2] = '0';
1.1144 - }
1.1145 -
1.1146 - zAux = contextMalloc(pCtx, strlen(z)+1);
1.1147 - if( zAux ){
1.1148 - strcpy(zAux, z);
1.1149 - sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata);
1.1150 - }
1.1151 - zRet[i*2+1] = ' ';
1.1152 - }
1.1153 - }
1.1154 - sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata);
1.1155 -}
1.1156 -#endif /* SQLITE_TEST */
1.1157 -
1.1158 -#ifdef SQLITE_TEST
1.1159 -/*
1.1160 -** A function to test error reporting from user functions. This function
1.1161 -** returns a copy of it's first argument as an error.
1.1162 -*/
1.1163 -static void test_error(
1.1164 - sqlite3_context *pCtx,
1.1165 - int nArg,
1.1166 - sqlite3_value **argv
1.1167 -){
1.1168 - sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), 0);
1.1169 -}
1.1170 -#endif /* SQLITE_TEST */
1.1171 -
1.1172 -/*
1.1173 -** An instance of the following structure holds the context of a
1.1174 -** sum() or avg() aggregate computation.
1.1175 -*/
1.1176 -typedef struct SumCtx SumCtx;
1.1177 -struct SumCtx {
1.1178 - double rSum; /* Floating point sum */
1.1179 - i64 iSum; /* Integer sum */
1.1180 - i64 cnt; /* Number of elements summed */
1.1181 - u8 overflow; /* True if integer overflow seen */
1.1182 - u8 approx; /* True if non-integer value was input to the sum */
1.1183 -};
1.1184 -
1.1185 -/*
1.1186 -** Routines used to compute the sum, average, and total.
1.1187 -**
1.1188 -** The SUM() function follows the (broken) SQL standard which means
1.1189 -** that it returns NULL if it sums over no inputs. TOTAL returns
1.1190 -** 0.0 in that case. In addition, TOTAL always returns a float where
1.1191 -** SUM might return an integer if it never encounters a floating point
1.1192 -** value. TOTAL never fails, but SUM might through an exception if
1.1193 -** it overflows an integer.
1.1194 -*/
1.1195 -static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1.1196 - SumCtx *p;
1.1197 - int type;
1.1198 - assert( argc==1 );
1.1199 - p = sqlite3_aggregate_context(context, sizeof(*p));
1.1200 - type = sqlite3_value_numeric_type(argv[0]);
1.1201 - if( p && type!=SQLITE_NULL ){
1.1202 - p->cnt++;
1.1203 - if( type==SQLITE_INTEGER ){
1.1204 - i64 v = sqlite3_value_int64(argv[0]);
1.1205 - p->rSum += v;
1.1206 - if( (p->approx|p->overflow)==0 ){
1.1207 - i64 iNewSum = p->iSum + v;
1.1208 - int s1 = p->iSum >> (sizeof(i64)*8-1);
1.1209 - int s2 = v >> (sizeof(i64)*8-1);
1.1210 - int s3 = iNewSum >> (sizeof(i64)*8-1);
1.1211 - p->overflow = (s1&s2&~s3) | (~s1&~s2&s3);
1.1212 - p->iSum = iNewSum;
1.1213 - }
1.1214 - }else{
1.1215 - p->rSum += sqlite3_value_double(argv[0]);
1.1216 - p->approx = 1;
1.1217 - }
1.1218 - }
1.1219 -}
1.1220 -static void sumFinalize(sqlite3_context *context){
1.1221 - SumCtx *p;
1.1222 - p = sqlite3_aggregate_context(context, 0);
1.1223 - if( p && p->cnt>0 ){
1.1224 - if( p->overflow ){
1.1225 - sqlite3_result_error(context,"integer overflow",-1);
1.1226 - }else if( p->approx ){
1.1227 - sqlite3_result_double(context, p->rSum);
1.1228 - }else{
1.1229 - sqlite3_result_int64(context, p->iSum);
1.1230 - }
1.1231 - }
1.1232 -}
1.1233 -static void avgFinalize(sqlite3_context *context){
1.1234 - SumCtx *p;
1.1235 - p = sqlite3_aggregate_context(context, 0);
1.1236 - if( p && p->cnt>0 ){
1.1237 - sqlite3_result_double(context, p->rSum/(double)p->cnt);
1.1238 - }
1.1239 -}
1.1240 -static void totalFinalize(sqlite3_context *context){
1.1241 - SumCtx *p;
1.1242 - p = sqlite3_aggregate_context(context, 0);
1.1243 - sqlite3_result_double(context, p ? p->rSum : 0.0);
1.1244 -}
1.1245 -
1.1246 -/*
1.1247 -** The following structure keeps track of state information for the
1.1248 -** count() aggregate function.
1.1249 -*/
1.1250 -typedef struct CountCtx CountCtx;
1.1251 -struct CountCtx {
1.1252 - i64 n;
1.1253 -};
1.1254 -
1.1255 -/*
1.1256 -** Routines to implement the count() aggregate function.
1.1257 -*/
1.1258 -static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1.1259 - CountCtx *p;
1.1260 - p = sqlite3_aggregate_context(context, sizeof(*p));
1.1261 - if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
1.1262 - p->n++;
1.1263 - }
1.1264 -}
1.1265 -static void countFinalize(sqlite3_context *context){
1.1266 - CountCtx *p;
1.1267 - p = sqlite3_aggregate_context(context, 0);
1.1268 - sqlite3_result_int64(context, p ? p->n : 0);
1.1269 -}
1.1270 -
1.1271 -/*
1.1272 -** Routines to implement min() and max() aggregate functions.
1.1273 -*/
1.1274 -static void minmaxStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1.1275 - Mem *pArg = (Mem *)argv[0];
1.1276 - Mem *pBest;
1.1277 -
1.1278 - if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1.1279 - pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
1.1280 - if( !pBest ) return;
1.1281 -
1.1282 - if( pBest->flags ){
1.1283 - int max;
1.1284 - int cmp;
1.1285 - CollSeq *pColl = sqlite3GetFuncCollSeq(context);
1.1286 - /* This step function is used for both the min() and max() aggregates,
1.1287 - ** the only difference between the two being that the sense of the
1.1288 - ** comparison is inverted. For the max() aggregate, the
1.1289 - ** sqlite3_user_data() function returns (void *)-1. For min() it
1.1290 - ** returns (void *)db, where db is the sqlite3* database pointer.
1.1291 - ** Therefore the next statement sets variable 'max' to 1 for the max()
1.1292 - ** aggregate, or 0 for min().
1.1293 - */
1.1294 - max = sqlite3_user_data(context)!=0;
1.1295 - cmp = sqlite3MemCompare(pBest, pArg, pColl);
1.1296 - if( (max && cmp<0) || (!max && cmp>0) ){
1.1297 - sqlite3VdbeMemCopy(pBest, pArg);
1.1298 - }
1.1299 - }else{
1.1300 - sqlite3VdbeMemCopy(pBest, pArg);
1.1301 - }
1.1302 -}
1.1303 -static void minMaxFinalize(sqlite3_context *context){
1.1304 - sqlite3_value *pRes;
1.1305 - pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
1.1306 - if( pRes ){
1.1307 - if( pRes->flags ){
1.1308 - sqlite3_result_value(context, pRes);
1.1309 - }
1.1310 - sqlite3VdbeMemRelease(pRes);
1.1311 - }
1.1312 -}
1.1313 -
1.1314 -
1.1315 -/*
1.1316 -** This function registered all of the above C functions as SQL
1.1317 -** functions. This should be the only routine in this file with
1.1318 -** external linkage.
1.1319 -*/
1.1320 -void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
1.1321 - static const struct {
1.1322 - char *zName;
1.1323 - signed char nArg;
1.1324 - u8 argType; /* ff: db 1: 0, 2: 1, 3: 2,... N: N-1. */
1.1325 - u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */
1.1326 - u8 needCollSeq;
1.1327 - void (*xFunc)(sqlite3_context*,int,sqlite3_value **);
1.1328 - } aFuncs[] = {
1.1329 - { "min", -1, 0, SQLITE_UTF8, 1, minmaxFunc },
1.1330 - { "min", 0, 0, SQLITE_UTF8, 1, 0 },
1.1331 - { "max", -1, 1, SQLITE_UTF8, 1, minmaxFunc },
1.1332 - { "max", 0, 1, SQLITE_UTF8, 1, 0 },
1.1333 - { "typeof", 1, 0, SQLITE_UTF8, 0, typeofFunc },
1.1334 - { "length", 1, 0, SQLITE_UTF8, 0, lengthFunc },
1.1335 - { "substr", 3, 0, SQLITE_UTF8, 0, substrFunc },
1.1336 - { "abs", 1, 0, SQLITE_UTF8, 0, absFunc },
1.1337 - { "round", 1, 0, SQLITE_UTF8, 0, roundFunc },
1.1338 - { "round", 2, 0, SQLITE_UTF8, 0, roundFunc },
1.1339 - { "upper", 1, 0, SQLITE_UTF8, 0, upperFunc },
1.1340 - { "lower", 1, 0, SQLITE_UTF8, 0, lowerFunc },
1.1341 - { "coalesce", -1, 0, SQLITE_UTF8, 0, ifnullFunc },
1.1342 - { "coalesce", 0, 0, SQLITE_UTF8, 0, 0 },
1.1343 - { "coalesce", 1, 0, SQLITE_UTF8, 0, 0 },
1.1344 - { "hex", 1, 0, SQLITE_UTF8, 0, hexFunc },
1.1345 - { "ifnull", 2, 0, SQLITE_UTF8, 1, ifnullFunc },
1.1346 - { "random", -1, 0, SQLITE_UTF8, 0, randomFunc },
1.1347 - { "randomblob", 1, 0, SQLITE_UTF8, 0, randomBlob },
1.1348 - { "nullif", 2, 0, SQLITE_UTF8, 1, nullifFunc },
1.1349 - { "sqlite_version", 0, 0, SQLITE_UTF8, 0, versionFunc},
1.1350 - { "quote", 1, 0, SQLITE_UTF8, 0, quoteFunc },
1.1351 - { "last_insert_rowid", 0, 0xff, SQLITE_UTF8, 0, last_insert_rowid },
1.1352 - { "changes", 0, 0xff, SQLITE_UTF8, 0, changes },
1.1353 - { "total_changes", 0, 0xff, SQLITE_UTF8, 0, total_changes },
1.1354 - { "replace", 3, 0, SQLITE_UTF8, 0, replaceFunc },
1.1355 - { "ltrim", 1, 1, SQLITE_UTF8, 0, trimFunc },
1.1356 - { "ltrim", 2, 1, SQLITE_UTF8, 0, trimFunc },
1.1357 - { "rtrim", 1, 2, SQLITE_UTF8, 0, trimFunc },
1.1358 - { "rtrim", 2, 2, SQLITE_UTF8, 0, trimFunc },
1.1359 - { "trim", 1, 3, SQLITE_UTF8, 0, trimFunc },
1.1360 - { "trim", 2, 3, SQLITE_UTF8, 0, trimFunc },
1.1361 - { "zeroblob", 1, 0, SQLITE_UTF8, 0, zeroblobFunc },
1.1362 -#ifdef SQLITE_SOUNDEX
1.1363 - { "soundex", 1, 0, SQLITE_UTF8, 0, soundexFunc},
1.1364 -#endif
1.1365 -#ifndef SQLITE_OMIT_LOAD_EXTENSION
1.1366 - { "load_extension", 1, 0xff, SQLITE_UTF8, 0, loadExt },
1.1367 - { "load_extension", 2, 0xff, SQLITE_UTF8, 0, loadExt },
1.1368 -#endif
1.1369 -#ifdef SQLITE_TEST
1.1370 - { "randstr", 2, 0, SQLITE_UTF8, 0, randStr },
1.1371 - { "test_destructor", 1, 0xff, SQLITE_UTF8, 0, test_destructor},
1.1372 - { "test_destructor_count", 0, 0, SQLITE_UTF8, 0, test_destructor_count},
1.1373 - { "test_auxdata", -1, 0, SQLITE_UTF8, 0, test_auxdata},
1.1374 - { "test_error", 1, 0, SQLITE_UTF8, 0, test_error},
1.1375 -#endif
1.1376 - };
1.1377 - static const struct {
1.1378 - char *zName;
1.1379 - signed char nArg;
1.1380 - u8 argType;
1.1381 - u8 needCollSeq;
1.1382 - void (*xStep)(sqlite3_context*,int,sqlite3_value**);
1.1383 - void (*xFinalize)(sqlite3_context*);
1.1384 - } aAggs[] = {
1.1385 - { "min", 1, 0, 1, minmaxStep, minMaxFinalize },
1.1386 - { "max", 1, 1, 1, minmaxStep, minMaxFinalize },
1.1387 - { "sum", 1, 0, 0, sumStep, sumFinalize },
1.1388 - { "total", 1, 0, 0, sumStep, totalFinalize },
1.1389 - { "avg", 1, 0, 0, sumStep, avgFinalize },
1.1390 - { "count", 0, 0, 0, countStep, countFinalize },
1.1391 - { "count", 1, 0, 0, countStep, countFinalize },
1.1392 - };
1.1393 - int i;
1.1394 -
1.1395 - for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
1.1396 - void *pArg;
1.1397 - u8 argType = aFuncs[i].argType;
1.1398 - if( argType==0xff ){
1.1399 - pArg = db;
1.1400 - }else{
1.1401 - pArg = (void*)(int)argType;
1.1402 - }
1.1403 - sqlite3CreateFunc(db, aFuncs[i].zName, aFuncs[i].nArg,
1.1404 - aFuncs[i].eTextRep, pArg, aFuncs[i].xFunc, 0, 0);
1.1405 - if( aFuncs[i].needCollSeq ){
1.1406 - FuncDef *pFunc = sqlite3FindFunction(db, aFuncs[i].zName,
1.1407 - strlen(aFuncs[i].zName), aFuncs[i].nArg, aFuncs[i].eTextRep, 0);
1.1408 - if( pFunc && aFuncs[i].needCollSeq ){
1.1409 - pFunc->needCollSeq = 1;
1.1410 - }
1.1411 - }
1.1412 - }
1.1413 -#ifndef SQLITE_OMIT_ALTERTABLE
1.1414 - sqlite3AlterFunctions(db);
1.1415 -#endif
1.1416 -#ifndef SQLITE_OMIT_PARSER
1.1417 - sqlite3AttachFunctions(db);
1.1418 -#endif
1.1419 - for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){
1.1420 - void *pArg = (void*)(int)aAggs[i].argType;
1.1421 - sqlite3CreateFunc(db, aAggs[i].zName, aAggs[i].nArg, SQLITE_UTF8,
1.1422 - pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize);
1.1423 - if( aAggs[i].needCollSeq ){
1.1424 - FuncDef *pFunc = sqlite3FindFunction( db, aAggs[i].zName,
1.1425 - strlen(aAggs[i].zName), aAggs[i].nArg, SQLITE_UTF8, 0);
1.1426 - if( pFunc && aAggs[i].needCollSeq ){
1.1427 - pFunc->needCollSeq = 1;
1.1428 - }
1.1429 - }
1.1430 - }
1.1431 - sqlite3RegisterDateTimeFunctions(db);
1.1432 - if( !db->mallocFailed ){
1.1433 - int rc = sqlite3_overload_function(db, "MATCH", 2);
1.1434 - assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
1.1435 - if( rc==SQLITE_NOMEM ){
1.1436 - db->mallocFailed = 1;
1.1437 - }
1.1438 - }
1.1439 -#ifdef SQLITE_SSE
1.1440 - (void)sqlite3SseFunctions(db);
1.1441 -#endif
1.1442 -#ifdef SQLITE_CASE_SENSITIVE_LIKE
1.1443 - sqlite3RegisterLikeFunctions(db, 1);
1.1444 -#else
1.1445 - sqlite3RegisterLikeFunctions(db, 0);
1.1446 -#endif
1.1447 -}
1.1448 -
1.1449 -/*
1.1450 -** Set the LIKEOPT flag on the 2-argument function with the given name.
1.1451 -*/
1.1452 -static void setLikeOptFlag(sqlite3 *db, const char *zName, int flagVal){
1.1453 - FuncDef *pDef;
1.1454 - pDef = sqlite3FindFunction(db, zName, strlen(zName), 2, SQLITE_UTF8, 0);
1.1455 - if( pDef ){
1.1456 - pDef->flags = flagVal;
1.1457 - }
1.1458 -}
1.1459 -
1.1460 -/*
1.1461 -** Register the built-in LIKE and GLOB functions. The caseSensitive
1.1462 -** parameter determines whether or not the LIKE operator is case
1.1463 -** sensitive. GLOB is always case sensitive.
1.1464 -*/
1.1465 -void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
1.1466 - struct compareInfo *pInfo;
1.1467 - if( caseSensitive ){
1.1468 - pInfo = (struct compareInfo*)&likeInfoAlt;
1.1469 - }else{
1.1470 - pInfo = (struct compareInfo*)&likeInfoNorm;
1.1471 - }
1.1472 - sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0);
1.1473 - sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0);
1.1474 - sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8,
1.1475 - (struct compareInfo*)&globInfo, likeFunc, 0,0);
1.1476 - setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE);
1.1477 - setLikeOptFlag(db, "like",
1.1478 - caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE);
1.1479 -}
1.1480 -
1.1481 -/*
1.1482 -** pExpr points to an expression which implements a function. If
1.1483 -** it is appropriate to apply the LIKE optimization to that function
1.1484 -** then set aWc[0] through aWc[2] to the wildcard characters and
1.1485 -** return TRUE. If the function is not a LIKE-style function then
1.1486 -** return FALSE.
1.1487 -*/
1.1488 -int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
1.1489 - FuncDef *pDef;
1.1490 - if( pExpr->op!=TK_FUNCTION || !pExpr->pList ){
1.1491 - return 0;
1.1492 - }
1.1493 - if( pExpr->pList->nExpr!=2 ){
1.1494 - return 0;
1.1495 - }
1.1496 - pDef = sqlite3FindFunction(db, (char*)pExpr->token.z, pExpr->token.n, 2,
1.1497 - SQLITE_UTF8, 0);
1.1498 - if( pDef==0 || (pDef->flags & SQLITE_FUNC_LIKE)==0 ){
1.1499 - return 0;
1.1500 - }
1.1501 -
1.1502 - /* The memcpy() statement assumes that the wildcard characters are
1.1503 - ** the first three statements in the compareInfo structure. The
1.1504 - ** asserts() that follow verify that assumption
1.1505 - */
1.1506 - memcpy(aWc, pDef->pUserData, 3);
1.1507 - assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
1.1508 - assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
1.1509 - assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
1.1510 - *pIsNocase = (pDef->flags & SQLITE_FUNC_CASE)==0;
1.1511 - return 1;
1.1512 -}
