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