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