1 /* 2 ** 2002 February 23 3 ** 4 ** The author disclaims copyright to this source code. In place of 5 ** a legal notice, here is a blessing: 6 ** 7 ** May you do good and not evil. 8 ** May you find forgiveness for yourself and forgive others. 9 ** May you share freely, never taking more than you give. 10 ** 11 ************************************************************************* 12 ** This file contains the C functions that implement various SQL 13 ** functions of SQLite. 14 ** 15 ** There is only one exported symbol in this file - the function 16 ** sqliteRegisterBuildinFunctions() found at the bottom of the file. 17 ** All other code has file scope. 18 ** 19 ** $Id: func.c,v 1.176 2007/11/01 17:38:31 drh Exp $ 20 */ 21 #include "sqliteInt.h" 22 #include <ctype.h> 23 #include <stdlib.h> 24 #include <assert.h> 25 #include "vdbeInt.h" 26 27 28 /* 29 ** Return the collating function associated with a function. 30 */ 31 static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){ 32 return context->pColl; 33 } 34 35 /* 36 ** Implementation of the non-aggregate min() and max() functions 37 */ 38 static void minmaxFunc( 39 sqlite3_context *context, 40 int argc, 41 sqlite3_value **argv 42 ){ 43 int i; 44 int mask; /* 0 for min() or 0xffffffff for max() */ 45 int iBest; 46 CollSeq *pColl; 47 48 if( argc==0 ) return; 49 mask = sqlite3_user_data(context)==0 ? 0 : -1; 50 pColl = sqlite3GetFuncCollSeq(context); 51 assert( pColl ); 52 assert( mask==-1 || mask==0 ); 53 iBest = 0; 54 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 55 for(i=1; i<argc; i++){ 56 if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return; 57 if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){ 58 iBest = i; 59 } 60 } 61 sqlite3_result_value(context, argv[iBest]); 62 } 63 64 /* 65 ** Return the type of the argument. 66 */ 67 static void typeofFunc( 68 sqlite3_context *context, 69 int argc, 70 sqlite3_value **argv 71 ){ 72 const char *z = 0; 73 switch( sqlite3_value_type(argv[0]) ){ 74 case SQLITE_NULL: z = "null"; break; 75 case SQLITE_INTEGER: z = "integer"; break; 76 case SQLITE_TEXT: z = "text"; break; 77 case SQLITE_FLOAT: z = "real"; break; 78 case SQLITE_BLOB: z = "blob"; break; 79 } 80 sqlite3_result_text(context, z, -1, SQLITE_STATIC); 81 } 82 83 84 /* 85 ** Implementation of the length() function 86 */ 87 static void lengthFunc( 88 sqlite3_context *context, 89 int argc, 90 sqlite3_value **argv 91 ){ 92 int len; 93 94 assert( argc==1 ); 95 switch( sqlite3_value_type(argv[0]) ){ 96 case SQLITE_BLOB: 97 case SQLITE_INTEGER: 98 case SQLITE_FLOAT: { 99 sqlite3_result_int(context, sqlite3_value_bytes(argv[0])); 100 break; 101 } 102 case SQLITE_TEXT: { 103 const unsigned char *z = sqlite3_value_text(argv[0]); 104 if( z==0 ) return; 105 len = 0; 106 while( *z ){ 107 len++; 108 SQLITE_SKIP_UTF8(z); 109 } 110 sqlite3_result_int(context, len); 111 break; 112 } 113 default: { 114 sqlite3_result_null(context); 115 break; 116 } 117 } 118 } 119 120 /* 121 ** Implementation of the abs() function 122 */ 123 static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 124 assert( argc==1 ); 125 switch( sqlite3_value_type(argv[0]) ){ 126 case SQLITE_INTEGER: { 127 i64 iVal = sqlite3_value_int64(argv[0]); 128 if( iVal<0 ){ 129 if( (iVal<<1)==0 ){ 130 sqlite3_result_error(context, "integer overflow", -1); 131 return; 132 } 133 iVal = -iVal; 134 } 135 sqlite3_result_int64(context, iVal); 136 break; 137 } 138 case SQLITE_NULL: { 139 sqlite3_result_null(context); 140 break; 141 } 142 default: { 143 double rVal = sqlite3_value_double(argv[0]); 144 if( rVal<0 ) rVal = -rVal; 145 sqlite3_result_double(context, rVal); 146 break; 147 } 148 } 149 } 150 151 /* 152 ** Implementation of the substr() function. 153 ** 154 ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1. 155 ** p1 is 1-indexed. So substr(x,1,1) returns the first character 156 ** of x. If x is text, then we actually count UTF-8 characters. 157 ** If x is a blob, then we count bytes. 158 ** 159 ** If p1 is negative, then we begin abs(p1) from the end of x[]. 160 */ 161 static void substrFunc( 162 sqlite3_context *context, 163 int argc, 164 sqlite3_value **argv 165 ){ 166 const unsigned char *z; 167 const unsigned char *z2; 168 int len; 169 int p0type; 170 i64 p1, p2; 171 172 assert( argc==3 || argc==2 ); 173 p0type = sqlite3_value_type(argv[0]); 174 if( p0type==SQLITE_BLOB ){ 175 len = sqlite3_value_bytes(argv[0]); 176 z = sqlite3_value_blob(argv[0]); 177 if( z==0 ) return; 178 assert( len==sqlite3_value_bytes(argv[0]) ); 179 }else{ 180 z = sqlite3_value_text(argv[0]); 181 if( z==0 ) return; 182 len = 0; 183 for(z2=z; *z2; len++){ 184 SQLITE_SKIP_UTF8(z2); 185 } 186 } 187 p1 = sqlite3_value_int(argv[1]); 188 if( argc==3 ){ 189 p2 = sqlite3_value_int(argv[2]); 190 }else{ 191 p2 = SQLITE_MAX_LENGTH; 192 } 193 if( p1<0 ){ 194 p1 += len; 195 if( p1<0 ){ 196 p2 += p1; 197 p1 = 0; 198 } 199 }else if( p1>0 ){ 200 p1--; 201 } 202 if( p1+p2>len ){ 203 p2 = len-p1; 204 } 205 if( p0type!=SQLITE_BLOB ){ 206 while( *z && p1 ){ 207 SQLITE_SKIP_UTF8(z); 208 p1--; 209 } 210 for(z2=z; *z2 && p2; p2--){ 211 SQLITE_SKIP_UTF8(z2); 212 } 213 sqlite3_result_text(context, (char*)z, z2-z, SQLITE_TRANSIENT); 214 }else{ 215 if( p2<0 ) p2 = 0; 216 sqlite3_result_blob(context, (char*)&z[p1], p2, SQLITE_TRANSIENT); 217 } 218 } 219 220 /* 221 ** Implementation of the round() function 222 */ 223 static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 224 int n = 0; 225 double r; 226 char zBuf[500]; /* larger than the %f representation of the largest double */ 227 assert( argc==1 || argc==2 ); 228 if( argc==2 ){ 229 if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return; 230 n = sqlite3_value_int(argv[1]); 231 if( n>30 ) n = 30; 232 if( n<0 ) n = 0; 233 } 234 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 235 r = sqlite3_value_double(argv[0]); 236 sqlite3_snprintf(sizeof(zBuf),zBuf,"%.*f",n,r); 237 sqlite3AtoF(zBuf, &r); 238 sqlite3_result_double(context, r); 239 } 240 241 /* 242 ** Allocate nByte bytes of space using sqlite3_malloc(). If the 243 ** allocation fails, call sqlite3_result_error_nomem() to notify 244 ** the database handle that malloc() has failed. 245 */ 246 static void *contextMalloc(sqlite3_context *context, int nByte){ 247 char *z = sqlite3_malloc(nByte); 248 if( !z && nByte>0 ){ 249 sqlite3_result_error_nomem(context); 250 } 251 return z; 252 } 253 254 /* 255 ** Implementation of the upper() and lower() SQL functions. 256 */ 257 static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 258 char *z1; 259 const char *z2; 260 int i, n; 261 if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return; 262 z2 = (char*)sqlite3_value_text(argv[0]); 263 n = sqlite3_value_bytes(argv[0]); 264 /* Verify that the call to _bytes() does not invalidate the _text() pointer */ 265 assert( z2==(char*)sqlite3_value_text(argv[0]) ); 266 if( z2 ){ 267 z1 = contextMalloc(context, n+1); 268 if( z1 ){ 269 memcpy(z1, z2, n+1); 270 for(i=0; z1[i]; i++){ 271 z1[i] = toupper(z1[i]); 272 } 273 sqlite3_result_text(context, z1, -1, sqlite3_free); 274 } 275 } 276 } 277 static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 278 char *z1; 279 const char *z2; 280 int i, n; 281 if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return; 282 z2 = (char*)sqlite3_value_text(argv[0]); 283 n = sqlite3_value_bytes(argv[0]); 284 /* Verify that the call to _bytes() does not invalidate the _text() pointer */ 285 assert( z2==(char*)sqlite3_value_text(argv[0]) ); 286 if( z2 ){ 287 z1 = contextMalloc(context, n+1); 288 if( z1 ){ 289 memcpy(z1, z2, n+1); 290 for(i=0; z1[i]; i++){ 291 z1[i] = tolower(z1[i]); 292 } 293 sqlite3_result_text(context, z1, -1, sqlite3_free); 294 } 295 } 296 } 297 298 /* 299 ** Implementation of the IFNULL(), NVL(), and COALESCE() functions. 300 ** All three do the same thing. They return the first non-NULL 301 ** argument. 302 */ 303 static void ifnullFunc( 304 sqlite3_context *context, 305 int argc, 306 sqlite3_value **argv 307 ){ 308 int i; 309 for(i=0; i<argc; i++){ 310 if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){ 311 sqlite3_result_value(context, argv[i]); 312 break; 313 } 314 } 315 } 316 317 /* 318 ** Implementation of random(). Return a random integer. 319 */ 320 static void randomFunc( 321 sqlite3_context *context, 322 int argc, 323 sqlite3_value **argv 324 ){ 325 sqlite_int64 r; 326 sqlite3Randomness(sizeof(r), &r); 327 if( (r<<1)==0 ) r = 0; /* Prevent 0x8000.... as the result so that we */ 328 /* can always do abs() of the result */ 329 sqlite3_result_int64(context, r); 330 } 331 332 /* 333 ** Implementation of randomblob(N). Return a random blob 334 ** that is N bytes long. 335 */ 336 static void randomBlob( 337 sqlite3_context *context, 338 int argc, 339 sqlite3_value **argv 340 ){ 341 int n; 342 unsigned char *p; 343 assert( argc==1 ); 344 n = sqlite3_value_int(argv[0]); 345 if( n<1 ){ 346 n = 1; 347 } 348 if( n>SQLITE_MAX_LENGTH ){ 349 sqlite3_result_error_toobig(context); 350 return; 351 } 352 p = contextMalloc(context, n); 353 if( p ){ 354 sqlite3Randomness(n, p); 355 sqlite3_result_blob(context, (char*)p, n, sqlite3_free); 356 } 357 } 358 359 /* 360 ** Implementation of the last_insert_rowid() SQL function. The return 361 ** value is the same as the sqlite3_last_insert_rowid() API function. 362 */ 363 static void last_insert_rowid( 364 sqlite3_context *context, 365 int arg, 366 sqlite3_value **argv 367 ){ 368 sqlite3 *db = sqlite3_user_data(context); 369 sqlite3_result_int64(context, sqlite3_last_insert_rowid(db)); 370 } 371 372 /* 373 ** Implementation of the changes() SQL function. The return value is the 374 ** same as the sqlite3_changes() API function. 375 */ 376 static void changes( 377 sqlite3_context *context, 378 int arg, 379 sqlite3_value **argv 380 ){ 381 sqlite3 *db = sqlite3_user_data(context); 382 sqlite3_result_int(context, sqlite3_changes(db)); 383 } 384 385 /* 386 ** Implementation of the total_changes() SQL function. The return value is 387 ** the same as the sqlite3_total_changes() API function. 388 */ 389 static void total_changes( 390 sqlite3_context *context, 391 int arg, 392 sqlite3_value **argv 393 ){ 394 sqlite3 *db = sqlite3_user_data(context); 395 sqlite3_result_int(context, sqlite3_total_changes(db)); 396 } 397 398 /* 399 ** A structure defining how to do GLOB-style comparisons. 400 */ 401 struct compareInfo { 402 u8 matchAll; 403 u8 matchOne; 404 u8 matchSet; 405 u8 noCase; 406 }; 407 408 static const struct compareInfo globInfo = { '*', '?', '[', 0 }; 409 /* The correct SQL-92 behavior is for the LIKE operator to ignore 410 ** case. Thus 'a' LIKE 'A' would be true. */ 411 static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 }; 412 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator 413 ** is case sensitive causing 'a' LIKE 'A' to be false */ 414 static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 }; 415 416 /* 417 ** Compare two UTF-8 strings for equality where the first string can 418 ** potentially be a "glob" expression. Return true (1) if they 419 ** are the same and false (0) if they are different. 420 ** 421 ** Globbing rules: 422 ** 423 ** '*' Matches any sequence of zero or more characters. 424 ** 425 ** '?' Matches exactly one character. 426 ** 427 ** [...] Matches one character from the enclosed list of 428 ** characters. 429 ** 430 ** [^...] Matches one character not in the enclosed list. 431 ** 432 ** With the [...] and [^...] matching, a ']' character can be included 433 ** in the list by making it the first character after '[' or '^'. A 434 ** range of characters can be specified using '-'. Example: 435 ** "[a-z]" matches any single lower-case letter. To match a '-', make 436 ** it the last character in the list. 437 ** 438 ** This routine is usually quick, but can be N**2 in the worst case. 439 ** 440 ** Hints: to match '*' or '?', put them in "[]". Like this: 441 ** 442 ** abc[*]xyz Matches "abc*xyz" only 443 */ 444 static int patternCompare( 445 const u8 *zPattern, /* The glob pattern */ 446 const u8 *zString, /* The string to compare against the glob */ 447 const struct compareInfo *pInfo, /* Information about how to do the compare */ 448 const int esc /* The escape character */ 449 ){ 450 int c, c2; 451 int invert; 452 int seen; 453 u8 matchOne = pInfo->matchOne; 454 u8 matchAll = pInfo->matchAll; 455 u8 matchSet = pInfo->matchSet; 456 u8 noCase = pInfo->noCase; 457 int prevEscape = 0; /* True if the previous character was 'escape' */ 458 459 while( (c = sqlite3Utf8Read(zPattern,0,&zPattern))!=0 ){ 460 if( !prevEscape && c==matchAll ){ 461 while( (c=sqlite3Utf8Read(zPattern,0,&zPattern)) == matchAll 462 || c == matchOne ){ 463 if( c==matchOne && sqlite3Utf8Read(zString, 0, &zString)==0 ){ 464 return 0; 465 } 466 } 467 if( c==0 ){ 468 return 1; 469 }else if( c==esc ){ 470 c = sqlite3Utf8Read(zPattern, 0, &zPattern); 471 if( c==0 ){ 472 return 0; 473 } 474 }else if( c==matchSet ){ 475 assert( esc==0 ); /* This is GLOB, not LIKE */ 476 assert( matchSet<0x80 ); /* '[' is a single-byte character */ 477 while( *zString && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){ 478 SQLITE_SKIP_UTF8(zString); 479 } 480 return *zString!=0; 481 } 482 while( (c2 = sqlite3Utf8Read(zString,0,&zString))!=0 ){ 483 if( noCase ){ 484 c2 = c2<0x80 ? sqlite3UpperToLower[c2] : c2; 485 c = c<0x80 ? sqlite3UpperToLower[c] : c; 486 while( c2 != 0 && c2 != c ){ 487 c2 = sqlite3Utf8Read(zString, 0, &zString); 488 if( c2<0x80 ) c2 = sqlite3UpperToLower[c2]; 489 } 490 }else{ 491 while( c2 != 0 && c2 != c ){ 492 c2 = sqlite3Utf8Read(zString, 0, &zString); 493 } 494 } 495 if( c2==0 ) return 0; 496 if( patternCompare(zPattern,zString,pInfo,esc) ) return 1; 497 } 498 return 0; 499 }else if( !prevEscape && c==matchOne ){ 500 if( sqlite3Utf8Read(zString, 0, &zString)==0 ){ 501 return 0; 502 } 503 }else if( c==matchSet ){ 504 int prior_c = 0; 505 assert( esc==0 ); /* This only occurs for GLOB, not LIKE */ 506 seen = 0; 507 invert = 0; 508 c = sqlite3Utf8Read(zString, 0, &zString); 509 if( c==0 ) return 0; 510 c2 = sqlite3Utf8Read(zPattern, 0, &zPattern); 511 if( c2=='^' ){ 512 invert = 1; 513 c2 = sqlite3Utf8Read(zPattern, 0, &zPattern); 514 } 515 if( c2==']' ){ 516 if( c==']' ) seen = 1; 517 c2 = sqlite3Utf8Read(zPattern, 0, &zPattern); 518 } 519 while( c2 && c2!=']' ){ 520 if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){ 521 c2 = sqlite3Utf8Read(zPattern, 0, &zPattern); 522 if( c>=prior_c && c<=c2 ) seen = 1; 523 prior_c = 0; 524 }else{ 525 if( c==c2 ){ 526 seen = 1; 527 } 528 prior_c = c2; 529 } 530 c2 = sqlite3Utf8Read(zPattern, 0, &zPattern); 531 } 532 if( c2==0 || (seen ^ invert)==0 ){ 533 return 0; 534 } 535 }else if( esc==c && !prevEscape ){ 536 prevEscape = 1; 537 }else{ 538 c2 = sqlite3Utf8Read(zString, 0, &zString); 539 if( noCase ){ 540 c = c<0x80 ? sqlite3UpperToLower[c] : c; 541 c2 = c2<0x80 ? sqlite3UpperToLower[c2] : c2; 542 } 543 if( c!=c2 ){ 544 return 0; 545 } 546 prevEscape = 0; 547 } 548 } 549 return *zString==0; 550 } 551 552 /* 553 ** Count the number of times that the LIKE operator (or GLOB which is 554 ** just a variation of LIKE) gets called. This is used for testing 555 ** only. 556 */ 557 #ifdef SQLITE_TEST 558 int sqlite3_like_count = 0; 559 #endif 560 561 562 /* 563 ** Implementation of the like() SQL function. This function implements 564 ** the build-in LIKE operator. The first argument to the function is the 565 ** pattern and the second argument is the string. So, the SQL statements: 566 ** 567 ** A LIKE B 568 ** 569 ** is implemented as like(B,A). 570 ** 571 ** This same function (with a different compareInfo structure) computes 572 ** the GLOB operator. 573 */ 574 static void likeFunc( 575 sqlite3_context *context, 576 int argc, 577 sqlite3_value **argv 578 ){ 579 const unsigned char *zA, *zB; 580 int escape = 0; 581 582 zB = sqlite3_value_text(argv[0]); 583 zA = sqlite3_value_text(argv[1]); 584 585 /* Limit the length of the LIKE or GLOB pattern to avoid problems 586 ** of deep recursion and N*N behavior in patternCompare(). 587 */ 588 if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){ 589 sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); 590 return; 591 } 592 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */ 593 594 if( argc==3 ){ 595 /* The escape character string must consist of a single UTF-8 character. 596 ** Otherwise, return an error. 597 */ 598 const unsigned char *zEsc = sqlite3_value_text(argv[2]); 599 if( zEsc==0 ) return; 600 if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){ 601 sqlite3_result_error(context, 602 "ESCAPE expression must be a single character", -1); 603 return; 604 } 605 escape = sqlite3Utf8Read(zEsc, 0, &zEsc); 606 } 607 if( zA && zB ){ 608 struct compareInfo *pInfo = sqlite3_user_data(context); 609 #ifdef SQLITE_TEST 610 sqlite3_like_count++; 611 #endif 612 613 sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape)); 614 } 615 } 616 617 /* 618 ** Implementation of the NULLIF(x,y) function. The result is the first 619 ** argument if the arguments are different. The result is NULL if the 620 ** arguments are equal to each other. 621 */ 622 static void nullifFunc( 623 sqlite3_context *context, 624 int argc, 625 sqlite3_value **argv 626 ){ 627 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 628 if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ 629 sqlite3_result_value(context, argv[0]); 630 } 631 } 632 633 /* 634 ** Implementation of the VERSION(*) function. The result is the version 635 ** of the SQLite library that is running. 636 */ 637 static void versionFunc( 638 sqlite3_context *context, 639 int argc, 640 sqlite3_value **argv 641 ){ 642 sqlite3_result_text(context, sqlite3_version, -1, SQLITE_STATIC); 643 } 644 645 /* Array for converting from half-bytes (nybbles) into ASCII hex 646 ** digits. */ 647 static const char hexdigits[] = { 648 '0', '1', '2', '3', '4', '5', '6', '7', 649 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 650 }; 651 652 /* 653 ** EXPERIMENTAL - This is not an official function. The interface may 654 ** change. This function may disappear. Do not write code that depends 655 ** on this function. 656 ** 657 ** Implementation of the QUOTE() function. This function takes a single 658 ** argument. If the argument is numeric, the return value is the same as 659 ** the argument. If the argument is NULL, the return value is the string 660 ** "NULL". Otherwise, the argument is enclosed in single quotes with 661 ** single-quote escapes. 662 */ 663 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ 664 if( argc<1 ) return; 665 switch( sqlite3_value_type(argv[0]) ){ 666 case SQLITE_NULL: { 667 sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC); 668 break; 669 } 670 case SQLITE_INTEGER: 671 case SQLITE_FLOAT: { 672 sqlite3_result_value(context, argv[0]); 673 break; 674 } 675 case SQLITE_BLOB: { 676 char *zText = 0; 677 char const *zBlob = sqlite3_value_blob(argv[0]); 678 int nBlob = sqlite3_value_bytes(argv[0]); 679 assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 680 681 if( 2*nBlob+4>SQLITE_MAX_LENGTH ){ 682 sqlite3_result_error_toobig(context); 683 return; 684 } 685 zText = (char *)contextMalloc(context, (2*nBlob)+4); 686 if( zText ){ 687 int i; 688 for(i=0; i<nBlob; i++){ 689 zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F]; 690 zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; 691 } 692 zText[(nBlob*2)+2] = '\''; 693 zText[(nBlob*2)+3] = '\0'; 694 zText[0] = 'X'; 695 zText[1] = '\''; 696 sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); 697 sqlite3_free(zText); 698 } 699 break; 700 } 701 case SQLITE_TEXT: { 702 int i,j; 703 u64 n; 704 const unsigned char *zArg = sqlite3_value_text(argv[0]); 705 char *z; 706 707 if( zArg==0 ) return; 708 for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; } 709 if( i+n+3>SQLITE_MAX_LENGTH ){ 710 sqlite3_result_error_toobig(context); 711 return; 712 } 713 z = contextMalloc(context, i+n+3); 714 if( z ){ 715 z[0] = '\''; 716 for(i=0, j=1; zArg[i]; i++){ 717 z[j++] = zArg[i]; 718 if( zArg[i]=='\'' ){ 719 z[j++] = '\''; 720 } 721 } 722 z[j++] = '\''; 723 z[j] = 0; 724 sqlite3_result_text(context, z, j, sqlite3_free); 725 } 726 } 727 } 728 } 729 730 /* 731 ** The hex() function. Interpret the argument as a blob. Return 732 ** a hexadecimal rendering as text. 733 */ 734 static void hexFunc( 735 sqlite3_context *context, 736 int argc, 737 sqlite3_value **argv 738 ){ 739 int i, n; 740 const unsigned char *pBlob; 741 char *zHex, *z; 742 assert( argc==1 ); 743 pBlob = sqlite3_value_blob(argv[0]); 744 n = sqlite3_value_bytes(argv[0]); 745 if( n*2+1>SQLITE_MAX_LENGTH ){ 746 sqlite3_result_error_toobig(context); 747 return; 748 } 749 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ 750 z = zHex = contextMalloc(context, n*2 + 1); 751 if( zHex ){ 752 for(i=0; i<n; i++, pBlob++){ 753 unsigned char c = *pBlob; 754 *(z++) = hexdigits[(c>>4)&0xf]; 755 *(z++) = hexdigits[c&0xf]; 756 } 757 *z = 0; 758 sqlite3_result_text(context, zHex, n*2, sqlite3_free); 759 } 760 } 761 762 /* 763 ** The zeroblob(N) function returns a zero-filled blob of size N bytes. 764 */ 765 static void zeroblobFunc( 766 sqlite3_context *context, 767 int argc, 768 sqlite3_value **argv 769 ){ 770 i64 n; 771 assert( argc==1 ); 772 n = sqlite3_value_int64(argv[0]); 773 if( n>SQLITE_MAX_LENGTH ){ 774 sqlite3_result_error_toobig(context); 775 }else{ 776 sqlite3_result_zeroblob(context, n); 777 } 778 } 779 780 /* 781 ** The replace() function. Three arguments are all strings: call 782 ** them A, B, and C. The result is also a string which is derived 783 ** from A by replacing every occurance of B with C. The match 784 ** must be exact. Collating sequences are not used. 785 */ 786 static void replaceFunc( 787 sqlite3_context *context, 788 int argc, 789 sqlite3_value **argv 790 ){ 791 const unsigned char *zStr; /* The input string A */ 792 const unsigned char *zPattern; /* The pattern string B */ 793 const unsigned char *zRep; /* The replacement string C */ 794 unsigned char *zOut; /* The output */ 795 int nStr; /* Size of zStr */ 796 int nPattern; /* Size of zPattern */ 797 int nRep; /* Size of zRep */ 798 i64 nOut; /* Maximum size of zOut */ 799 int loopLimit; /* Last zStr[] that might match zPattern[] */ 800 int i, j; /* Loop counters */ 801 802 assert( argc==3 ); 803 zStr = sqlite3_value_text(argv[0]); 804 if( zStr==0 ) return; 805 nStr = sqlite3_value_bytes(argv[0]); 806 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */ 807 zPattern = sqlite3_value_text(argv[1]); 808 if( zPattern==0 || zPattern[0]==0 ) return; 809 nPattern = sqlite3_value_bytes(argv[1]); 810 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */ 811 zRep = sqlite3_value_text(argv[2]); 812 if( zRep==0 ) return; 813 nRep = sqlite3_value_bytes(argv[2]); 814 assert( zRep==sqlite3_value_text(argv[2]) ); 815 nOut = nStr + 1; 816 assert( nOut<SQLITE_MAX_LENGTH ); 817 zOut = contextMalloc(context, (int)nOut); 818 if( zOut==0 ){ 819 return; 820 } 821 loopLimit = nStr - nPattern; 822 for(i=j=0; i<=loopLimit; i++){ 823 if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){ 824 zOut[j++] = zStr[i]; 825 }else{ 826 u8 *zOld; 827 nOut += nRep - nPattern; 828 if( nOut>=SQLITE_MAX_LENGTH ){ 829 sqlite3_result_error_toobig(context); 830 sqlite3_free(zOut); 831 return; 832 } 833 zOld = zOut; 834 zOut = sqlite3_realloc(zOut, (int)nOut); 835 if( zOut==0 ){ 836 sqlite3_result_error_nomem(context); 837 sqlite3_free(zOld); 838 return; 839 } 840 memcpy(&zOut[j], zRep, nRep); 841 j += nRep; 842 i += nPattern-1; 843 } 844 } 845 assert( j+nStr-i+1==nOut ); 846 memcpy(&zOut[j], &zStr[i], nStr-i); 847 j += nStr - i; 848 assert( j<=nOut ); 849 zOut[j] = 0; 850 sqlite3_result_text(context, (char*)zOut, j, sqlite3_free); 851 } 852 853 /* 854 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions. 855 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both. 856 */ 857 static void trimFunc( 858 sqlite3_context *context, 859 int argc, 860 sqlite3_value **argv 861 ){ 862 const unsigned char *zIn; /* Input string */ 863 const unsigned char *zCharSet; /* Set of characters to trim */ 864 int nIn; /* Number of bytes in input */ 865 int flags; /* 1: trimleft 2: trimright 3: trim */ 866 int i; /* Loop counter */ 867 unsigned char *aLen; /* Length of each character in zCharSet */ 868 const unsigned char **azChar; /* Individual characters in zCharSet */ 869 int nChar; /* Number of characters in zCharSet */ 870 871 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ 872 return; 873 } 874 zIn = sqlite3_value_text(argv[0]); 875 if( zIn==0 ) return; 876 nIn = sqlite3_value_bytes(argv[0]); 877 assert( zIn==sqlite3_value_text(argv[0]) ); 878 if( argc==1 ){ 879 static const unsigned char lenOne[] = { 1 }; 880 static const unsigned char *azOne[] = { (u8*)" " }; 881 nChar = 1; 882 aLen = (u8*)lenOne; 883 azChar = azOne; 884 zCharSet = 0; 885 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ 886 return; 887 }else{ 888 const unsigned char *z; 889 for(z=zCharSet, nChar=0; *z; nChar++){ 890 SQLITE_SKIP_UTF8(z); 891 } 892 if( nChar>0 ){ 893 azChar = contextMalloc(context, nChar*(sizeof(char*)+1)); 894 if( azChar==0 ){ 895 return; 896 } 897 aLen = (unsigned char*)&azChar[nChar]; 898 for(z=zCharSet, nChar=0; *z; nChar++){ 899 azChar[nChar] = z; 900 SQLITE_SKIP_UTF8(z); 901 aLen[nChar] = z - azChar[nChar]; 902 } 903 } 904 } 905 if( nChar>0 ){ 906 flags = (int)sqlite3_user_data(context); 907 if( flags & 1 ){ 908 while( nIn>0 ){ 909 int len; 910 for(i=0; i<nChar; i++){ 911 len = aLen[i]; 912 if( memcmp(zIn, azChar[i], len)==0 ) break; 913 } 914 if( i>=nChar ) break; 915 zIn += len; 916 nIn -= len; 917 } 918 } 919 if( flags & 2 ){ 920 while( nIn>0 ){ 921 int len; 922 for(i=0; i<nChar; i++){ 923 len = aLen[i]; 924 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break; 925 } 926 if( i>=nChar ) break; 927 nIn -= len; 928 } 929 } 930 if( zCharSet ){ 931 sqlite3_free(azChar); 932 } 933 } 934 sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT); 935 } 936 937 #ifdef SQLITE_SOUNDEX 938 /* 939 ** Compute the soundex encoding of a word. 940 */ 941 static void soundexFunc( 942 sqlite3_context *context, 943 int argc, 944 sqlite3_value **argv 945 ){ 946 char zResult[8]; 947 const u8 *zIn; 948 int i, j; 949 static const unsigned char iCode[] = { 950 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 951 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 952 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 953 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 954 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 955 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 956 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, 957 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, 958 }; 959 assert( argc==1 ); 960 zIn = (u8*)sqlite3_value_text(argv[0]); 961 if( zIn==0 ) zIn = (u8*)""; 962 for(i=0; zIn[i] && !isalpha(zIn[i]); i++){} 963 if( zIn[i] ){ 964 u8 prevcode = iCode[zIn[i]&0x7f]; 965 zResult[0] = toupper(zIn[i]); 966 for(j=1; j<4 && zIn[i]; i++){ 967 int code = iCode[zIn[i]&0x7f]; 968 if( code>0 ){ 969 if( code!=prevcode ){ 970 prevcode = code; 971 zResult[j++] = code + '0'; 972 } 973 }else{ 974 prevcode = 0; 975 } 976 } 977 while( j<4 ){ 978 zResult[j++] = '0'; 979 } 980 zResult[j] = 0; 981 sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); 982 }else{ 983 sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); 984 } 985 } 986 #endif 987 988 #ifndef SQLITE_OMIT_LOAD_EXTENSION 989 /* 990 ** A function that loads a shared-library extension then returns NULL. 991 */ 992 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){ 993 const char *zFile = (const char *)sqlite3_value_text(argv[0]); 994 const char *zProc; 995 sqlite3 *db = sqlite3_user_data(context); 996 char *zErrMsg = 0; 997 998 if( argc==2 ){ 999 zProc = (const char *)sqlite3_value_text(argv[1]); 1000 }else{ 1001 zProc = 0; 1002 } 1003 if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){ 1004 sqlite3_result_error(context, zErrMsg, -1); 1005 sqlite3_free(zErrMsg); 1006 } 1007 } 1008 #endif 1009 1010 #ifdef SQLITE_TEST 1011 /* 1012 ** This function generates a string of random characters. Used for 1013 ** generating test data. 1014 */ 1015 static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){ 1016 static const unsigned char zSrc[] = 1017 "abcdefghijklmnopqrstuvwxyz" 1018 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 1019 "0123456789" 1020 ".-!,:*^+=_|?/<> "; 1021 int iMin, iMax, n, r, i; 1022 unsigned char zBuf[1000]; 1023 1024 /* It used to be possible to call randstr() with any number of arguments, 1025 ** but now it is registered with SQLite as requiring exactly 2. 1026 */ 1027 assert(argc==2); 1028 1029 iMin = sqlite3_value_int(argv[0]); 1030 if( iMin<0 ) iMin = 0; 1031 if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1; 1032 iMax = sqlite3_value_int(argv[1]); 1033 if( iMax<iMin ) iMax = iMin; 1034 if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1; 1035 n = iMin; 1036 if( iMax>iMin ){ 1037 sqlite3Randomness(sizeof(r), &r); 1038 r &= 0x7fffffff; 1039 n += r%(iMax + 1 - iMin); 1040 } 1041 assert( n<sizeof(zBuf) ); 1042 sqlite3Randomness(n, zBuf); 1043 for(i=0; i<n; i++){ 1044 zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)]; 1045 } 1046 zBuf[n] = 0; 1047 sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT); 1048 } 1049 #endif /* SQLITE_TEST */ 1050 1051 #ifdef SQLITE_TEST 1052 /* 1053 ** The following two SQL functions are used to test returning a text 1054 ** result with a destructor. Function 'test_destructor' takes one argument 1055 ** and returns the same argument interpreted as TEXT. A destructor is 1056 ** passed with the sqlite3_result_text() call. 1057 ** 1058 ** SQL function 'test_destructor_count' returns the number of outstanding 1059 ** allocations made by 'test_destructor'; 1060 ** 1061 ** WARNING: Not threadsafe. 1062 */ 1063 static int test_destructor_count_var = 0; 1064 static void destructor(void *p){ 1065 char *zVal = (char *)p; 1066 assert(zVal); 1067 zVal--; 1068 sqlite3_free(zVal); 1069 test_destructor_count_var--; 1070 } 1071 static void test_destructor( 1072 sqlite3_context *pCtx, 1073 int nArg, 1074 sqlite3_value **argv 1075 ){ 1076 char *zVal; 1077 int len; 1078 sqlite3 *db = sqlite3_user_data(pCtx); 1079 1080 test_destructor_count_var++; 1081 assert( nArg==1 ); 1082 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1083 len = sqlite3ValueBytes(argv[0], ENC(db)); 1084 zVal = contextMalloc(pCtx, len+3); 1085 if( !zVal ){ 1086 return; 1087 } 1088 zVal[len+1] = 0; 1089 zVal[len+2] = 0; 1090 zVal++; 1091 memcpy(zVal, sqlite3ValueText(argv[0], ENC(db)), len); 1092 if( ENC(db)==SQLITE_UTF8 ){ 1093 sqlite3_result_text(pCtx, zVal, -1, destructor); 1094 #ifndef SQLITE_OMIT_UTF16 1095 }else if( ENC(db)==SQLITE_UTF16LE ){ 1096 sqlite3_result_text16le(pCtx, zVal, -1, destructor); 1097 }else{ 1098 sqlite3_result_text16be(pCtx, zVal, -1, destructor); 1099 #endif /* SQLITE_OMIT_UTF16 */ 1100 } 1101 } 1102 static void test_destructor_count( 1103 sqlite3_context *pCtx, 1104 int nArg, 1105 sqlite3_value **argv 1106 ){ 1107 sqlite3_result_int(pCtx, test_destructor_count_var); 1108 } 1109 #endif /* SQLITE_TEST */ 1110 1111 #ifdef SQLITE_TEST 1112 /* 1113 ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata() 1114 ** interface. 1115 ** 1116 ** The test_auxdata() SQL function attempts to register each of its arguments 1117 ** as auxiliary data. If there are no prior registrations of aux data for 1118 ** that argument (meaning the argument is not a constant or this is its first 1119 ** call) then the result for that argument is 0. If there is a prior 1120 ** registration, the result for that argument is 1. The overall result 1121 ** is the individual argument results separated by spaces. 1122 */ 1123 static void free_test_auxdata(void *p) {sqlite3_free(p);} 1124 static void test_auxdata( 1125 sqlite3_context *pCtx, 1126 int nArg, 1127 sqlite3_value **argv 1128 ){ 1129 int i; 1130 char *zRet = contextMalloc(pCtx, nArg*2); 1131 if( !zRet ) return; 1132 memset(zRet, 0, nArg*2); 1133 for(i=0; i<nArg; i++){ 1134 char const *z = (char*)sqlite3_value_text(argv[i]); 1135 if( z ){ 1136 char *zAux = sqlite3_get_auxdata(pCtx, i); 1137 if( zAux ){ 1138 zRet[i*2] = '1'; 1139 if( strcmp(zAux, z) ){ 1140 sqlite3_result_error(pCtx, "Auxilary data corruption", -1); 1141 return; 1142 } 1143 }else { 1144 zRet[i*2] = '0'; 1145 } 1146 1147 zAux = contextMalloc(pCtx, strlen(z)+1); 1148 if( zAux ){ 1149 strcpy(zAux, z); 1150 sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata); 1151 } 1152 zRet[i*2+1] = ' '; 1153 } 1154 } 1155 sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata); 1156 } 1157 #endif /* SQLITE_TEST */ 1158 1159 #ifdef SQLITE_TEST 1160 /* 1161 ** A function to test error reporting from user functions. This function 1162 ** returns a copy of it's first argument as an error. 1163 */ 1164 static void test_error( 1165 sqlite3_context *pCtx, 1166 int nArg, 1167 sqlite3_value **argv 1168 ){ 1169 sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), 0); 1170 } 1171 #endif /* SQLITE_TEST */ 1172 1173 /* 1174 ** An instance of the following structure holds the context of a 1175 ** sum() or avg() aggregate computation. 1176 */ 1177 typedef struct SumCtx SumCtx; 1178 struct SumCtx { 1179 double rSum; /* Floating point sum */ 1180 i64 iSum; /* Integer sum */ 1181 i64 cnt; /* Number of elements summed */ 1182 u8 overflow; /* True if integer overflow seen */ 1183 u8 approx; /* True if non-integer value was input to the sum */ 1184 }; 1185 1186 /* 1187 ** Routines used to compute the sum, average, and total. 1188 ** 1189 ** The SUM() function follows the (broken) SQL standard which means 1190 ** that it returns NULL if it sums over no inputs. TOTAL returns 1191 ** 0.0 in that case. In addition, TOTAL always returns a float where 1192 ** SUM might return an integer if it never encounters a floating point 1193 ** value. TOTAL never fails, but SUM might through an exception if 1194 ** it overflows an integer. 1195 */ 1196 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1197 SumCtx *p; 1198 int type; 1199 assert( argc==1 ); 1200 p = sqlite3_aggregate_context(context, sizeof(*p)); 1201 type = sqlite3_value_numeric_type(argv[0]); 1202 if( p && type!=SQLITE_NULL ){ 1203 p->cnt++; 1204 if( type==SQLITE_INTEGER ){ 1205 i64 v = sqlite3_value_int64(argv[0]); 1206 p->rSum += v; 1207 if( (p->approx|p->overflow)==0 ){ 1208 i64 iNewSum = p->iSum + v; 1209 int s1 = p->iSum >> (sizeof(i64)*8-1); 1210 int s2 = v >> (sizeof(i64)*8-1); 1211 int s3 = iNewSum >> (sizeof(i64)*8-1); 1212 p->overflow = (s1&s2&~s3) | (~s1&~s2&s3); 1213 p->iSum = iNewSum; 1214 } 1215 }else{ 1216 p->rSum += sqlite3_value_double(argv[0]); 1217 p->approx = 1; 1218 } 1219 } 1220 } 1221 static void sumFinalize(sqlite3_context *context){ 1222 SumCtx *p; 1223 p = sqlite3_aggregate_context(context, 0); 1224 if( p && p->cnt>0 ){ 1225 if( p->overflow ){ 1226 sqlite3_result_error(context,"integer overflow",-1); 1227 }else if( p->approx ){ 1228 sqlite3_result_double(context, p->rSum); 1229 }else{ 1230 sqlite3_result_int64(context, p->iSum); 1231 } 1232 } 1233 } 1234 static void avgFinalize(sqlite3_context *context){ 1235 SumCtx *p; 1236 p = sqlite3_aggregate_context(context, 0); 1237 if( p && p->cnt>0 ){ 1238 sqlite3_result_double(context, p->rSum/(double)p->cnt); 1239 } 1240 } 1241 static void totalFinalize(sqlite3_context *context){ 1242 SumCtx *p; 1243 p = sqlite3_aggregate_context(context, 0); 1244 sqlite3_result_double(context, p ? p->rSum : 0.0); 1245 } 1246 1247 /* 1248 ** The following structure keeps track of state information for the 1249 ** count() aggregate function. 1250 */ 1251 typedef struct CountCtx CountCtx; 1252 struct CountCtx { 1253 i64 n; 1254 }; 1255 1256 /* 1257 ** Routines to implement the count() aggregate function. 1258 */ 1259 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1260 CountCtx *p; 1261 p = sqlite3_aggregate_context(context, sizeof(*p)); 1262 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ 1263 p->n++; 1264 } 1265 } 1266 static void countFinalize(sqlite3_context *context){ 1267 CountCtx *p; 1268 p = sqlite3_aggregate_context(context, 0); 1269 sqlite3_result_int64(context, p ? p->n : 0); 1270 } 1271 1272 /* 1273 ** Routines to implement min() and max() aggregate functions. 1274 */ 1275 static void minmaxStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1276 Mem *pArg = (Mem *)argv[0]; 1277 Mem *pBest; 1278 1279 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1280 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); 1281 if( !pBest ) return; 1282 1283 if( pBest->flags ){ 1284 int max; 1285 int cmp; 1286 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 1287 /* This step function is used for both the min() and max() aggregates, 1288 ** the only difference between the two being that the sense of the 1289 ** comparison is inverted. For the max() aggregate, the 1290 ** sqlite3_user_data() function returns (void *)-1. For min() it 1291 ** returns (void *)db, where db is the sqlite3* database pointer. 1292 ** Therefore the next statement sets variable 'max' to 1 for the max() 1293 ** aggregate, or 0 for min(). 1294 */ 1295 max = sqlite3_user_data(context)!=0; 1296 cmp = sqlite3MemCompare(pBest, pArg, pColl); 1297 if( (max && cmp<0) || (!max && cmp>0) ){ 1298 sqlite3VdbeMemCopy(pBest, pArg); 1299 } 1300 }else{ 1301 sqlite3VdbeMemCopy(pBest, pArg); 1302 } 1303 } 1304 static void minMaxFinalize(sqlite3_context *context){ 1305 sqlite3_value *pRes; 1306 pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); 1307 if( pRes ){ 1308 if( pRes->flags ){ 1309 sqlite3_result_value(context, pRes); 1310 } 1311 sqlite3VdbeMemRelease(pRes); 1312 } 1313 } 1314 1315 #ifdef SQLITE_GROUP_CONCAT 1316 /* 1317 ** group_concat(EXPR, ?SEPARATOR?) 1318 */ 1319 static void groupConcatStep( 1320 sqlite3_context *context, 1321 int argc, 1322 sqlite3_value **argv 1323 ){ 1324 const char *zVal; 1325 char **pzAccumulator; 1326 const char *zSep; 1327 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1328 zVal = sqlite3_value_text(argv[0]); 1329 pzAccumulator = (char**)sqlite3_aggregate_context(context, sizeof(char*)); 1330 if( pzAccumulator ){ 1331 if( *pzAccumulator==0 ){ 1332 *pzAccumulator = sqlite3_mprintf("%s", zVal); 1333 }else{ 1334 if( argc==2 ){ 1335 zSep = sqlite3_value_text(argv[1]); 1336 }else{ 1337 zSep = ","; 1338 } 1339 *pzAccumulator = sqlite3_mprintf("%z%s%s", *pzAccumulator, zSep, zVal); 1340 } 1341 } 1342 } 1343 static void groupConcatFinalize(sqlite3_context *context){ 1344 char **pzAccum; 1345 pzAccum = sqlite3_aggregate_context(context, 0); 1346 if( pzAccum ){ 1347 sqlite3_result_text(context, *pzAccum, -1, sqlite3_free); 1348 } 1349 } 1350 #endif /*SQLITE_GROUP_CONCAT*/ 1351 1352 /* 1353 ** This function registered all of the above C functions as SQL 1354 ** functions. This should be the only routine in this file with 1355 ** external linkage. 1356 */ 1357 void sqlite3RegisterBuiltinFunctions(sqlite3 *db){ 1358 static const struct { 1359 char *zName; 1360 signed char nArg; 1361 u8 argType; /* ff: db 1: 0, 2: 1, 3: 2,... N: N-1. */ 1362 u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */ 1363 u8 needCollSeq; 1364 void (*xFunc)(sqlite3_context*,int,sqlite3_value **); 1365 } aFuncs[] = { 1366 { "min", -1, 0, SQLITE_UTF8, 1, minmaxFunc }, 1367 { "min", 0, 0, SQLITE_UTF8, 1, 0 }, 1368 { "max", -1, 1, SQLITE_UTF8, 1, minmaxFunc }, 1369 { "max", 0, 1, SQLITE_UTF8, 1, 0 }, 1370 { "typeof", 1, 0, SQLITE_UTF8, 0, typeofFunc }, 1371 { "length", 1, 0, SQLITE_UTF8, 0, lengthFunc }, 1372 { "substr", 2, 0, SQLITE_UTF8, 0, substrFunc }, 1373 { "substr", 3, 0, SQLITE_UTF8, 0, substrFunc }, 1374 { "abs", 1, 0, SQLITE_UTF8, 0, absFunc }, 1375 { "round", 1, 0, SQLITE_UTF8, 0, roundFunc }, 1376 { "round", 2, 0, SQLITE_UTF8, 0, roundFunc }, 1377 { "upper", 1, 0, SQLITE_UTF8, 0, upperFunc }, 1378 { "lower", 1, 0, SQLITE_UTF8, 0, lowerFunc }, 1379 { "coalesce", -1, 0, SQLITE_UTF8, 0, ifnullFunc }, 1380 { "coalesce", 0, 0, SQLITE_UTF8, 0, 0 }, 1381 { "coalesce", 1, 0, SQLITE_UTF8, 0, 0 }, 1382 { "hex", 1, 0, SQLITE_UTF8, 0, hexFunc }, 1383 { "ifnull", 2, 0, SQLITE_UTF8, 1, ifnullFunc }, 1384 { "random", -1, 0, SQLITE_UTF8, 0, randomFunc }, 1385 { "randomblob", 1, 0, SQLITE_UTF8, 0, randomBlob }, 1386 { "nullif", 2, 0, SQLITE_UTF8, 1, nullifFunc }, 1387 { "sqlite_version", 0, 0, SQLITE_UTF8, 0, versionFunc}, 1388 { "quote", 1, 0, SQLITE_UTF8, 0, quoteFunc }, 1389 { "last_insert_rowid", 0, 0xff, SQLITE_UTF8, 0, last_insert_rowid }, 1390 { "changes", 0, 0xff, SQLITE_UTF8, 0, changes }, 1391 { "total_changes", 0, 0xff, SQLITE_UTF8, 0, total_changes }, 1392 { "replace", 3, 0, SQLITE_UTF8, 0, replaceFunc }, 1393 { "ltrim", 1, 1, SQLITE_UTF8, 0, trimFunc }, 1394 { "ltrim", 2, 1, SQLITE_UTF8, 0, trimFunc }, 1395 { "rtrim", 1, 2, SQLITE_UTF8, 0, trimFunc }, 1396 { "rtrim", 2, 2, SQLITE_UTF8, 0, trimFunc }, 1397 { "trim", 1, 3, SQLITE_UTF8, 0, trimFunc }, 1398 { "trim", 2, 3, SQLITE_UTF8, 0, trimFunc }, 1399 { "zeroblob", 1, 0, SQLITE_UTF8, 0, zeroblobFunc }, 1400 #ifdef SQLITE_SOUNDEX 1401 { "soundex", 1, 0, SQLITE_UTF8, 0, soundexFunc}, 1402 #endif 1403 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1404 { "load_extension", 1, 0xff, SQLITE_UTF8, 0, loadExt }, 1405 { "load_extension", 2, 0xff, SQLITE_UTF8, 0, loadExt }, 1406 #endif 1407 #ifdef SQLITE_TEST 1408 { "randstr", 2, 0, SQLITE_UTF8, 0, randStr }, 1409 { "test_destructor", 1, 0xff, SQLITE_UTF8, 0, test_destructor}, 1410 { "test_destructor_count", 0, 0, SQLITE_UTF8, 0, test_destructor_count}, 1411 { "test_auxdata", -1, 0, SQLITE_UTF8, 0, test_auxdata}, 1412 { "test_error", 1, 0, SQLITE_UTF8, 0, test_error}, 1413 #endif 1414 }; 1415 static const struct { 1416 char *zName; 1417 signed char nArg; 1418 u8 argType; 1419 u8 needCollSeq; 1420 void (*xStep)(sqlite3_context*,int,sqlite3_value**); 1421 void (*xFinalize)(sqlite3_context*); 1422 } aAggs[] = { 1423 { "min", 1, 0, 1, minmaxStep, minMaxFinalize }, 1424 { "max", 1, 1, 1, minmaxStep, minMaxFinalize }, 1425 { "sum", 1, 0, 0, sumStep, sumFinalize }, 1426 { "total", 1, 0, 0, sumStep, totalFinalize }, 1427 { "avg", 1, 0, 0, sumStep, avgFinalize }, 1428 { "count", 0, 0, 0, countStep, countFinalize }, 1429 { "count", 1, 0, 0, countStep, countFinalize }, 1430 #ifdef SQLITE_GROUP_CONCAT 1431 { "group_concat", 1, 0, 0, groupConcatStep, groupConcatFinalize }, 1432 { "group_concat", 2, 0, 0, groupConcatStep, groupConcatFinalize }, 1433 #endif 1434 }; 1435 int i; 1436 1437 for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ 1438 void *pArg; 1439 u8 argType = aFuncs[i].argType; 1440 if( argType==0xff ){ 1441 pArg = db; 1442 }else{ 1443 pArg = (void*)(int)argType; 1444 } 1445 sqlite3CreateFunc(db, aFuncs[i].zName, aFuncs[i].nArg, 1446 aFuncs[i].eTextRep, pArg, aFuncs[i].xFunc, 0, 0); 1447 if( aFuncs[i].needCollSeq ){ 1448 FuncDef *pFunc = sqlite3FindFunction(db, aFuncs[i].zName, 1449 strlen(aFuncs[i].zName), aFuncs[i].nArg, aFuncs[i].eTextRep, 0); 1450 if( pFunc && aFuncs[i].needCollSeq ){ 1451 pFunc->needCollSeq = 1; 1452 } 1453 } 1454 } 1455 #ifndef SQLITE_OMIT_ALTERTABLE 1456 sqlite3AlterFunctions(db); 1457 #endif 1458 #ifndef SQLITE_OMIT_PARSER 1459 sqlite3AttachFunctions(db); 1460 #endif 1461 for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){ 1462 void *pArg = (void*)(int)aAggs[i].argType; 1463 sqlite3CreateFunc(db, aAggs[i].zName, aAggs[i].nArg, SQLITE_UTF8, 1464 pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize); 1465 if( aAggs[i].needCollSeq ){ 1466 FuncDef *pFunc = sqlite3FindFunction( db, aAggs[i].zName, 1467 strlen(aAggs[i].zName), aAggs[i].nArg, SQLITE_UTF8, 0); 1468 if( pFunc && aAggs[i].needCollSeq ){ 1469 pFunc->needCollSeq = 1; 1470 } 1471 } 1472 } 1473 sqlite3RegisterDateTimeFunctions(db); 1474 if( !db->mallocFailed ){ 1475 int rc = sqlite3_overload_function(db, "MATCH", 2); 1476 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); 1477 if( rc==SQLITE_NOMEM ){ 1478 db->mallocFailed = 1; 1479 } 1480 } 1481 #ifdef SQLITE_SSE 1482 (void)sqlite3SseFunctions(db); 1483 #endif 1484 #ifdef SQLITE_CASE_SENSITIVE_LIKE 1485 sqlite3RegisterLikeFunctions(db, 1); 1486 #else 1487 sqlite3RegisterLikeFunctions(db, 0); 1488 #endif 1489 } 1490 1491 /* 1492 ** Set the LIKEOPT flag on the 2-argument function with the given name. 1493 */ 1494 static void setLikeOptFlag(sqlite3 *db, const char *zName, int flagVal){ 1495 FuncDef *pDef; 1496 pDef = sqlite3FindFunction(db, zName, strlen(zName), 2, SQLITE_UTF8, 0); 1497 if( pDef ){ 1498 pDef->flags = flagVal; 1499 } 1500 } 1501 1502 /* 1503 ** Register the built-in LIKE and GLOB functions. The caseSensitive 1504 ** parameter determines whether or not the LIKE operator is case 1505 ** sensitive. GLOB is always case sensitive. 1506 */ 1507 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ 1508 struct compareInfo *pInfo; 1509 if( caseSensitive ){ 1510 pInfo = (struct compareInfo*)&likeInfoAlt; 1511 }else{ 1512 pInfo = (struct compareInfo*)&likeInfoNorm; 1513 } 1514 sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0); 1515 sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0); 1516 sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8, 1517 (struct compareInfo*)&globInfo, likeFunc, 0,0); 1518 setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE); 1519 setLikeOptFlag(db, "like", 1520 caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE); 1521 } 1522 1523 /* 1524 ** pExpr points to an expression which implements a function. If 1525 ** it is appropriate to apply the LIKE optimization to that function 1526 ** then set aWc[0] through aWc[2] to the wildcard characters and 1527 ** return TRUE. If the function is not a LIKE-style function then 1528 ** return FALSE. 1529 */ 1530 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ 1531 FuncDef *pDef; 1532 if( pExpr->op!=TK_FUNCTION || !pExpr->pList ){ 1533 return 0; 1534 } 1535 if( pExpr->pList->nExpr!=2 ){ 1536 return 0; 1537 } 1538 pDef = sqlite3FindFunction(db, (char*)pExpr->token.z, pExpr->token.n, 2, 1539 SQLITE_UTF8, 0); 1540 if( pDef==0 || (pDef->flags & SQLITE_FUNC_LIKE)==0 ){ 1541 return 0; 1542 } 1543 1544 /* The memcpy() statement assumes that the wildcard characters are 1545 ** the first three statements in the compareInfo structure. The 1546 ** asserts() that follow verify that assumption 1547 */ 1548 memcpy(aWc, pDef->pUserData, 3); 1549 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); 1550 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); 1551 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); 1552 *pIsNocase = (pDef->flags & SQLITE_FUNC_CASE)==0; 1553 return 1; 1554 } 1555